<\/p>\n
Wenn ein Arbeitsplatz nicht nur zu gewöhnlichen Arbeitszeiten besetzt sein muss, sondern im Extremfall den kompletten Tag, müssen mehrere Mitarbeiter bereitstehen. Diese werden dann in mehreren Schichten über den Tag verteilt. Dabei ist es gar nicht so einfach, nicht den überblick zu verlieren – immerhin sollen alle Mitarbeiter im Laufe eines Zeitraums möglichst die angestrebte Anzahl Schichten durchführen. Gleichzeitig sollen zu jeder Zeit ausreichend Mitarbeiter arbeiten. Was liegt da näher, als dieses Problem mit einer geeigneten Access-Datenbank anzugehen <\/b><\/p>\n
Die in diesem Beitrag beschriebene Schichtplanung soll einige Ein- und Ausgabemöglichkeiten für die Erstellung von Schichtplänen berücksichtigen:<\/p>\n
Tabellen der Lösung<\/b><\/p>\n
Die Lösung benötigt zunächst eine Mitarbeitertabelle. Diese heißt tblMitarbeiter <\/b>und soll so einfach wie möglich ausgelegt werden. Das heißt, dass es zunächst nur ein Feld für die Bezeichnung des Mitarbeiters (Mitarbeiter<\/b>) sowie das Primärschlüsselfeld MitarbeiterID<\/b> gibt.<\/p>\n
Schichtarten<\/b><\/p>\n
Die Anwendung soll bezüglich der verschiedenen Schichten möglichst flexibel sein. Das heißt, dass es nicht nur die üblichen Schichten wie Früh-, Spät- und Nachtschicht geben soll. Der Benutzer kann den Tag nach Gutdünken in die gewünschten Schichten einteilen.<\/p>\n
Gegebenenfalls werden nur zwei Schichten pro Tag benötigt – etwa von 8 Uhr bis 14 Uhr und von 14 Uhr bis 22 Uhr.<\/p>\n
Oder zwei Schichten überlappen sich, weil es während der überlappung besonders viel zu tun gibt (etwa von 8 Uhr bis 16 Uhr und von 10 Uhr bis 20 Uhr).<\/p>\n
Deshalb sehen wir eine eigene Tabelle namens tblSchichtarten<\/b> zur Erfassung der verschiedenen Schichten vor (s. Bild 1). Diese Tabelle enthält die folgenden Felder:<\/p>\n
![\"Verwaltung](\"..\/fileadmin\/_temp_\/2013_05\/pic_906_001.png\")
<\/p>\n
Bild 1: Verwaltung von Arbeitstagen per Tabelle<\/span><\/b><\/p>\n Berücksichtigung von Fehltagen<\/b><\/p>\n Die Mitarbeiter stehen nicht immer zur Verfügung, da Sie wegen Urlaub, Krankheit oder Weiterbildung fehlen. Man neigt dazu, schnell eine eigene Tabelle zur Erfassung der Fehlzeiten zu erstellen.<\/p>\n In der Tat ist es aber viel sinnvoller, einfach einen oder mehrere weitere Einträge in der Tabelle tblSchichtarten <\/b>zu erfassen – beispielsweise mit den Werten Krankheit<\/b>, Urlaub <\/b>oder Fortbildung <\/b>im Feld Schichtart<\/b>.<\/p>\n Auf diese Weise ist es sogar möglich, die Fehlzeit auf bestimmte Schichten einzuschränken. Wenn ein Mitarbeiter beispielsweise mittags einen wichtigen Termin hat und dort keine Schicht wahrnehmen kann, trägt man für diese Schicht einfach als Schichtart die entsprechende Fehlzeitschichtart ein.<\/p>\n Damit diese Schichtarten deutlich von den übrigen, regulären Schichtarten unterschieden werden können, erhält die Tabelle tblSchichtarten <\/b>ein weiteres Feld namens Fehlschicht<\/b>. Dieses verwendet den Felddatentyp Ja\/Nein<\/b>.<\/p>\n Arbeitstage<\/b><\/p>\n Für einige Zwecke ist es sehr hilfreich, wenn es eine Tabelle mit allen benötigten Datumsangaben gibt. Den genauen Zweck erläutern wir später, aktuell reicht Folgendes: Die Tabelle heißt tblArbeitstage<\/b>, enthält die beiden Felder ArbeitstagID<\/b> und Arbeitstag <\/b>(Datum\/Uhrzeit<\/b>) und wird mit der Prozedur aus Listing 1 gefüllt.<\/p>\n Listing 1: Füllen der Tabelle tblArbeitstage<\/span><\/b><\/p>\n Die Prozedur erwartet den ersten und den letzten anzulegenden Tag als optionale Parameter. Wird der Starttag nicht angegeben, stellt die Prozedur diesen auf das aktuelle Datum ein.<\/p>\n Fehlt das Enddatum, erhält die Variable datEnde <\/b>den Inhalt von datStart <\/b>plus 1.000 Tage. Anschließend durchläuft die Prozedur in einer Schleife den angegebenen Datumsbereich und trägt die entsprechenden Datumsangaben in das Feld Arbeitstag <\/b>der Tabelle tblArbeitstage <\/b>ein.<\/p>\n Schichten speichern<\/b><\/p>\n Schließlich benötigen wir noch eine Tabelle, in der wir die jeweiligen Schichten für die Arbeitstage und Mitarbeiter speichern. Dies heißt tblSchichten <\/b>und ist wie in Bild 2 aufgebaut.<\/p>\n Bild 2: Die Tabelle tblSchichten enthält einen zusammengesetzten, eindeutigen Index für die beiden Felder MitarbeiterID und ArbeitstagID, damit für jeden Mitarbeiter nur eine Schicht je Arbeitstag festgelegt werden kann.<\/span><\/b><\/p>\n Schichtplan-Tabelle füllen<\/b><\/p>\n Die Tabelle tblSchichten <\/b>muss nun noch vorausgefüllt werden. Warum das – können wir die Kombinationen aus Mitarbeiter, Arbeitstag und Schichtart nicht zusammenstellen, wenn die Schicht geplant wird Grundsätzlich ginge dies schon – aber wir möchten ja bereits für das Festlegen der Schichten eine komfortable und übersichtliche Benutzeroberfläche liefern. Dafür ist es nötig, dass die entsprechenden Datensätze der Tabelle tblSchichten <\/b>bereits existieren – auch wenn die Schichtarten selbst dort noch nicht zugewiesen sind. Die gefüllte Tabelle soll schließlich wie in Bild 3 aussehen.<\/p>\n Bild 3: Die Tabelle tblSchichten mit einigen vorab angelegten Datensätzen<\/span><\/b><\/p>\n Das Füllen dieser Tabelle übernimmt die Prozedur SchichtenEintragen <\/b>aus Listing 2. Die Prozedur erzeugt zwei Recordset<\/b>-Objekte auf Basis der Tabellen tblMitarbeiter <\/b>und tblArbeitstage<\/b>. In einer äußeren Do While<\/b>-Schleife durchläuft die Prozedur die Datensätze der Tabelle tblMitarbeiter<\/b>, in einer inneren Schleife die Datensätze aus tblArbeitstage<\/b>.<\/p>\n Listing 2: Eintragen von Datensätzen in die Tabelle tblSchichten<\/span><\/b><\/p>\n Nach dem Durchlaufen aller Datensätze der inneren Schleife wird der Datensatzmarkierer für das Recordset rstArbeitstage <\/b>mit der MoveFirst<\/b>-Methode wieder auf den ersten Datensatz zurückgesetzt.<\/p>\n Innerhalb der beiden Schleifen befindet sich eine Anweisung, die der Tabelle tblSchichten <\/b>jeweils einen Datensatz hinzufügt. Diese stellt die Werte der Fremdschlüsselfelder MitarbeiterID <\/b>und ArbeitstagID <\/b>der Tabelle auf den jeweils aktuellen Wert des Primärschlüsselfelds der beiden Recordset<\/b>-Objekte ein.<\/p>\n Wenn ein neuer Mitarbeiter zur Tabelle tblMitarbeiterID <\/b>hinzugefügt wird oder wenn die Liste der Arbeitstage erweitert werden soll, braucht die Prozedur SchichtenEintragen <\/b>einfach nur erneut aufgerufen zu werden. Durch die deaktivierte Fehlerbehandlung werden bereits vorhandene Kombinationen aus Mitarbeiter und Arbeitstag weder überschrieben noch wird ein Fehler ausgelöst, wenn die Prozedur versucht, einen bereits vorhandenen und mit einem eindeutigen Index versehenen Datensatz erneut hinzuzufügen.<\/p>\n Schichtplan anzeigen<\/b><\/p>\n Nachdem wir die grundlegenden Daten für den Schichtplan in der Tabelle tblSchichten <\/b>vorliegen haben, benötigen wir noch ein Formular, mit dem wir diese Daten komfortabel bearbeiten können. Dazu gibt es eine Reihe Möglichkeiten: Wir können beispielsweise alle Arbeitstage für einen einzigen Mitarbeiter untereinander anzeigen und anbieten, die Schichten für jeden Arbeitstag auszuwählen.<\/p>\n Oder wir zeigen alle Mitarbeiter und ihre Schichten für einen ausgewählten Arbeitstag untereinander an und erlauben dem Benutzer, die Schichten für den aktuellen Arbeitstag zu bearbeiten.<\/p>\n Dies erlaubt natürlich nicht die übersicht, die wir uns erhoffen – nämlich die Darstellung in einer Matrix, bei der die Spaltenköpfe die Arbeitstage anzeigen und die Zeilenköpfe die Mitarbeiter.<\/p>\n Die Zellen dazwischen sollen das Eintragen der jeweiligen Schichtart für die Kombination aus Arbeitstag und Mitarbeiter erlauben.<\/p>\n Schichten per Kreuztabelle<\/b><\/p>\n Diese Ansicht lässt sich mit Access-Bordmitteln nur auf einem Wege erreichen – nämlich mithilfe einer Kreuztabellenabfrage. Diese Kreuztabelle soll ein Ergebnis ähnlich wie in Bild 4 liefern.<\/p>\n Bild 4: Ergebnis der Kreuztabellenabfrage, welche die Daten für die Anzeige der Schichtübersicht im Formular liefern soll<\/span><\/b><\/p>\n Wie entwerfen wir die Kreuztabellenabfrage, die ein solches Ergebnis liefert Dazu müssen wir zunächst einmal ermitteln, welche Daten wir dazu benötigen:<\/p>\n Legen Sie also eine neue Abfrage an und stellen Sie den Abfragetyp dann etwa über den entsprechenden Ribbon-Eintrag auf Kreuztabelle <\/b>ein. Fügen Sie die vier Tabellen tblSchichten<\/b>, tblSchichtarten<\/b>, tblMitarbeiter <\/b>und tblArbeitstage <\/b>hinzu.<\/p>\n Die Tabelle tblSchichten <\/b>sorgt für die Verknüpfung zwischen den drei übrigen Tabellen, welche die Daten für die Anzeige in der Kreuztabelle liefern.<\/p>\n Das heißt, dass Sie das Feld Mitarbeiter <\/b>als Zeilenüberschrift<\/b>, das Feld Arbeitstag <\/b>als Spaltenüberschrift <\/b>und das Feld Schichtart <\/b>als Wert <\/b>zum Abfrageentwurf hinzufügen.<\/p>\n Außerdem benötigen wir noch ein Kriterium, da eine Kreuztabelle nur eine begrenzte Anzahl von Spalten anzeigen kann. In diesem Fall fügen wir das Feld Arbeitstag zum Entwurf hinzu und legen in der Zeile Funktion <\/b>den Wert Bedingung <\/b>fest. Dann stellen wir für Testzwecke zunächst das folgende Filterkriterium ein (s. Bild 5):<\/p>\n Bild 5: Entwurf der Abfrage qryCTSchichten<\/span><\/b><\/p>\n Ein Wechsel zur Datenblattansicht liefert relative wenige Daten – zumindest, wenn Sie noch keine Werte im Feld SchichtartID <\/b>der Tabelle tblSchichten <\/b>eingetragen haben.<\/p>\n Der Grund ist, dass die Abfrage nur solche Datensätze liefert, für die alle Fremdschlüsselfelder der Tabelle tblSchichten <\/b>gefüllt sind. Dies ist natürlich beim Feld Schichtart-ID <\/b>nicht der Fall, da wir ja die Schichtarten für die einzelnen Arbeitstage erst noch festlegen wollen.<\/p>\n Also stellen Sie die Verknüpfungseigenschaften für die Beziehung zwischen den Tabellen tblSchichten <\/b>und tblSchichtarten <\/b>so ein, dass alle Datensätze der Tabelle tblSchichten <\/b>angezeigt werden – unabhängig davon, ob es bereits eine Verknüpfung zu einem Datensatz der Tabelle tblSchichtarten <\/b>gibt (s. Bild 6).<\/p>\n Bild 6: Einstellen der Verknüpfungseigenschaften so, dass alle Datensätze der Tabelle tblSchichten angezeigt werden<\/span><\/b><\/p>\n Die Kreuztabellenabfrage speichern wir nun noch unter dem Namen qryCTSchichten<\/b>.<\/p>\n Schichten im Formular anzeigen<\/b><\/p>\n Das Anzeigen der Kreuztabelle im Formular ist prinzipiell ganz einfach: Sie müssen einfach nur ein Hauptformular namens frmSchichten<\/b> erstellen und diesem ein Unterformular namens sfmSchichten <\/b>in der Datenblattansicht hinzufügen, das die Abfrage qryCTSchichten <\/b>als Datenherkunft verwendet.<\/p>\n Wenn Sie dann die Feldliste einblenden, erkennen Sie allerdings das erste Problem: Die Felder der Datenherkunft sind natürlich alle nach den Spaltenüberschriften der Kreuztabellenabfrage benannt, die ja dynamisch aus der Tabelle tblArbeitstage<\/b> ermittelt werden – und das auch noch in einem Format, in dem die Punkte im Datum durch Unterstriche ersetzt wurden.<\/p>\n Dennoch ziehen Sie zunächst alle Felder der Datenherkunft aus der Feldliste in den Detailbereich – irgendwie müssen wir ja beginnen. Das Ergebnis sieht dann wie in Bild 7 aus.<\/p>\n Bild 7: Der erste Entwurf des Unterformulars zur Anzeige des Ergebnisses der Kreuztabellenabfrage<\/span><\/b><\/p>\n Nun wurden die Felder nicht nur nach dem Wert der Spaltenüberschriften für die aktuellen Kriterien (also den gewählten Zeitraum) benannt, sondern auch die Eigenschaft Steuerelementinhalt <\/b>enthält den entsprechenden Feldnamen der Abfrage als Wert.<\/p>\n Nun möchten wir aber nicht immer den gleichen Datumsbereich anzeigen, sondern diesen dynamisch einstellen – beispielsweise über ein Textfeld, das den ersten Tag eines Datumsbereichs etwa von 28 Tagen entgegennimmt. Dazu sind einige Schritte nötig:<\/p>\n Kreuztabelle dynamisch<\/b><\/p>\n Wie erwähnt, soll die Kreuztabelle Ihre Daten in Abhängigkeit von einem bestimmten Startdatum liefern. Dazu muss diese mit einem Parameter ausgestattet werden. Bei herkömmlichen Abfragen geben Sie Parameter im Entwurf der Abfrage einfach als Bezeichnung des Parameters in eckigen Klammern an. Bei Kreuztabellenabfragen gelingt dies jedoch nicht – wir haben verschiedenste Varianten ausprobiert. Das soll uns jedoch nicht davon abhalten, die Kreuztabelle dynamisch zu gestalten. Wir statten diese dennoch einfach mit den benötigten Parametern aus:<\/p>\n Nun benötigen wir eine Prozedur, welche das Startdatum entgegennimmt und dieses in die Platzhalter der Kreuztabellenabfrage einbaut. Diese Prozedur heißt KreuztabelleFuellen<\/b> und ist in Listing 3 zu finden.<\/p>\n Listing 3: Kreuztabellenabfrage mit Parametern ausstatten<\/span><\/b><\/p>\n Die Prozedur liest zunächst den in der Abfrage qryCTSchichten<\/b> enthaltenen SQL-Code aus und schreibt diesen in die Variable strSQL<\/b>. Theoretisch könnte man diesen SQL-Code auch gleich fest im Code verdrahten, aber in einer gespeicherten Abfrage lassen sich änderungen doch leichter durchführen.<\/p>\n Für den in der Variablen strSQL <\/b>gespeicherten Ausdruck ersetzt die Abfrage zunächst den Platzhalter [Startdatum] <\/b>durch das mit dem Parameter dat <\/b>übergebene Datum. Der Platzhalter [Enddatum] <\/b>wird mit einem Datum versehen, das sich 28 Tage hinter dem Datum aus der Variablen dat <\/b>befindet.<\/p>\n Nach dem Ersetzen der Parameter der Kreuztabellenabfrage weist die Prozedur diese der Eigenschaft RecordSource <\/b>des im Unterformularsteuerelement enthaltenen Formulars zu.<\/p>\n Dann passt die Prozedur die Bezeichnungsfelder und Steuerelemente an, und zwar in einer For…Next<\/b>-Schleife über die Werte von 0 <\/b>bis 27<\/b>. Innerhalb der Schleife geschehen die folgenden Schritte:<\/p>\n Das waren die notwendigen Anpassungen – anschließend ruft die Prozedur noch die Routine SpaltenbreitenAnpassen <\/b>auf, welche die optimale Breite für die Spalten einstellt.<\/p>\n Spaltenbreiten anpassen<\/b><\/p>\n Das Anpassen der Spaltenbreiten erledigt die kleine Routine SpaltenbreitenAnpassen (s. Listing 4).<\/p>\n <\/p>\n Listing 4: Diese Prozedur bringt die Spalten in die optimale Breite zum Anzeigen ihres Inhalts.<\/span><\/b><\/p>\n Dabei durchläuft sie in einer For Each<\/b>-Schleife alle Steuerelemente des Unterformulars und prüft, ob diese den Typ acTextbox<\/b>, acCombobox <\/b>oder acCheckbox <\/b>aufweisen. Ist dies der Fall, stellt sie für die Eigenschaft ColumnWidth <\/b>den Wert -2 <\/b>ein. Dies entspricht einer Breite, bei der alle aktuell sichtbaren Einträge angezeigt werden.<\/p>\n Kreuztabelle nach Datumseingabe füllen<\/b><\/p>\n Wenn Sie nun in die Formularansicht wechseln, tut sich noch nichts – das Unterformular zeigt eine Reihe Fehler an.<\/p>\n Damit sich dies ändert, müssen wir die Prozedur KreuztabelleFuellen <\/b>auch noch auslösen. Dies soll beispielsweise geschehen, wenn der Benutzer ein Datum in das Textfeld txtStartdatum <\/b>einträgt. Dazu hinterlegen wir eine Prozedur, die durch das ändern des Wertes in txtStartdatum <\/b>ausgelöst wird. Die Prozedur enthält nur eine Anweisung, welche die Routine KreuztabelleFuellen <\/b>aufruft und das Datum aus txtStartdatum <\/b>als Parameter an die Routine übergibt:<\/p>\n Dies zeigt zumindest die noch leeren Felder der Kreuztabellenabfrage an.<\/p>\n Schichtplan bearbeiten<\/b><\/p>\n Nun soll der Benutzer wie in Bild 8 über die Kreuztabelle auch noch die Schichten für die jeweilige Kombination aus Mitarbeiter und Arbeitstag einstellen können. Dies sollte optimalerweise so gelingen, dass der Benutzer einen Bereich der Kreuztabelle markiert und dort das Kontextmenü aufruft, um die entsprechende Schichtart festzulegen oder diese gegebenenfalls zu entfernen.<\/p>\n Bild 8: Der Benutzer kann per Kontextmenü die Schichten für einen oder mehrere Mitarbeiter und\/oder Arbeitstage festlegen.<\/span><\/b><\/p>\n Dazu sind ein paar Vorüberlegungen nötig. Die Erste ist: Wie bringen wir das Formular dazu, für jedes Element der Kreuztabelle im Datenblatt bei Rechtsklick ein Kontextmenü anzuzeigen<\/p>\n Hier kommt wieder die übliche Frage: Lege ich für das Ereignis Bei Maustaste ab<\/b> eines jeden Steuerelements im Unterformular eine entsprechende Ereignisprozedur ab, die dann das Kontextmenü anzeigt (das wäre eine Fleißarbeit mit viel Copy und Paste, bei der gern mal ein Fehler auftritt) oder investiere ich etwas Hirnschmalz und baue eine Klasse, die für alle Steuerelemente einmal erstellt wird und deren Ereignis Bei Maustaste ab <\/b>implementiert Bei mir ist eher Hirnschmalz als Fleißarbeit angesagt, also verwenden wir hier die Version mit der Klasse.<\/p>\n Das zweite Problem ist: Wie sollen wir erkennen, welche Felder der Benutzer im Datenblatt markiert hat – und wenn dies erledigt ist, wie lesen wir aus, zu welchem Mitarbeiter und zu welchem Arbeitstag die markierten Zellen gehören<\/p>\n Erschwerend kommt hinzu, dass wir ja über die Kreuztabelle noch nicht einmal Zugriff auf die Primärschlüsselwerte der jeweiligen Datensätze der Tabellen tblMitarbeiter <\/b>und tblArbeitstage <\/b>erhalten, denn die Kreuztabelle nimmt ja nur die angezeigten Daten auf. Wie auch immer: Das Problem konnte gelöst werden und Sie lesen auf den kommenden Seiten, wie es funktioniert.<\/p>\n Ein Wrapper für jedes Wert-Feld<\/b><\/p>\n Als Erstes benötigen wir eine Collection<\/b>-Variable, welche alle Instanzen der noch zu erstellenden Klasse zum Kapseln der Felder der Kreuztabelle beziehungsweise der Steuerelemente des Unterformulars aufnimmt.<\/p>\n Diese deklarieren wir wie folgt im Kopf des Klassenmoduls Form_frmSchichten<\/b>:<\/p>\n Desweiteren benötigen wir noch weitere Variablen, deren Bedeutung im Folgenden noch erläutert wird:<\/p>\n Beim Laden des Formulars legen wir die Wrapper-Klassen für alle 28 Steuerelemente von txt01 <\/b>bix txt28 <\/b>an und weisen diesen jeweils einen Verweis auf das entsprechende Steuerelement zu.<\/p>\n Dies erledigen wir in der durch das Ereignis Beim Laden <\/b>ausgelösten Ereignisprozedur aus Listing 5.<\/p>\n Listing 5: Diese Ereignisprozedur wird beim Laden des Formulars ausgelöst.<\/span><\/b><\/p>\n Die Prozedur deklariert eine Objektvariable namens objTextbox<\/b>, die später die auf Basis der Klasse clsTextbox <\/b>erstellten Objekte referenziert, bevor diese in die Collection <\/b>namens colTextboxes <\/b>wandern. Dann ruft die Prozedur die Routine KreuztabelleFuellen<\/b> mit dem aktuellen Datum auf, damit gleich nach dem öffnen des Formulars entsprechende Daten angezeigt werden.<\/p>\n Die folgenden Zeilen kümmern sich um eine der oben aufgeführten, aber noch nicht beschriebenen Variablen: objDSF <\/b>nimmt nämlich einen Verweis auf eine Instanz einer Klasse namens clsData-sheetSelectionForm <\/b>auf.<\/p>\n Diese Klasse wird im Beitrag Datenblattmarkierungen <\/b>(www.access-im-unternehmen.de\/901<\/b>) ausführlich erläutert. Sie referenziert ein Formular in der Datenblattansicht und liefert nach Wunsch die Koordinaten der aktuellen Markierung im Datenblatt – entweder nach jeder änderung der Markierung oder nach Abruf der vier Eigenschaften SelLeft, SelWidth<\/b>, SelTop <\/b>und SelHeight<\/b>.<\/p>\n Wie wir diese einsetzen, erfahren Sie später – aktuell reicht es, wenn Sie wissen, dass diese Klasse beim Laden des Formulars instanziert und mit einem Verweis auf das Unterformular sfmSchichten <\/b>versorgt wird.<\/p>\n Danach füllt die Prozedur die mit dem Schlüsselwort WithEvents <\/b>referenzierte Variable sfm <\/b>ebenfalls mit einem Verweis auf das Unterformular sfmSchichten<\/b>. Sie legt fest, dass das aktuelle Klassenmodul gegebenenfalls auf das Ereignis Beim Anzeigen <\/b>des Unterformulars reagieren soll.<\/p>\n Dann ruft die Prozedur genau die zu diesem Zweck angelegte Ereignisprozedur sfm_Current <\/b>auf (Erläuterung siehe unten).<\/p>\n Bevor wir uns um diese Prozedur kümmern, stellt sich die Frage, warum wir diese im Klassenmodul des Hauptformulars implementieren. Dies ist einfach: Die Prozedur interagiert mit einigen Elementen, auf die auch vom Hauptformulars aus zugegriffen wird beziehungsweise die dort deklariert werden.<\/p>\n Um unnötige Abhängigkeiten zwischen Haupt- und Unterformular zu vermeiden, haben wir direkt den kompletten Code im Hauptformular untergebracht.<\/p>\n Bevor wir uns um die Prozedur sfm_Current <\/b>kümmern, schauen wir uns noch den Rest der Prozedur Form_Load <\/b>an.<\/p>\n Diese erstellt ein Recordset<\/b>-Objekt auf Basis der RecordsetClone<\/b>-Funktion des Unterformulars, also eine Kopie des dortigen Recordsets. In einer Do While<\/b>-Schleife durchläuft die Prozedur alle Datensätze des Recordset<\/b>-Objekts. Wie viele Datensätze hat eine Kreuztabelle aber nun eigentlich Nun: Genau so viele, wie die Datenherkunft Datensätze für die Zeilenüberschriften hergibt.<\/p>\n In unserem Fall entspricht dies also der Anzahl der Mitarbeiter der Tabelle tblMitarbeiter<\/b>. Beim Durchlaufen der Datensatzgruppe erweitert die Prozedur jeweils die als Array angelegte String-Variable strMitarbeiter <\/b>auf die aktuelle Anzahl durchlaufener Datensätze und trägt den Namen des Mitarbeiters des aktuellen Datensatzes für den entsprechenden Eintrag im Array ein.<\/p>\n Ihnen ist noch nicht klar, was wir mit diesem Array anfangen Das wird gleich geklärt.<\/p>\n Wenn das Unterformular aktualisiert wird<\/b><\/p>\n Das Ereignis sfm_Current <\/b>wird ja nicht nur durch die Form_Load<\/b>-Prozedur ausgeführt, sondern auch durch das Ereignis Beim Anzeigen <\/b>des Unterformulars.<\/p>\n Dieses wird sowohl ausgelöst, wenn der Benutzer den Datensatz wechselt als auch wenn dieser ein neues Datum in das Textfeld txtStartdatum <\/b>eingibt und somit das Unterformular komplett neu füllt.<\/p>\n Die Prozedur aus Listing 6 ist für die Vorbereitung der Kontextmenü-Funktionalität zum Anlegen von Schichtarten verantwortlich. Sie durchläuft dazu alle 28 Textfelder zur Anzeige der Schichtarten im Unterformular und erzeugt jeweils ein neues Objekt der Klasse clsTextbox<\/b>. Die geschieht in einer For…Next<\/b>-Schleife, welche mit der Laufvariablen i <\/b>von 1 <\/b>bis 28 <\/b>durchlaufen wird. Dabei wird das neue objTextbox<\/b>-Objekt erzeugt und mit einem Verweis auf das jeweilige Steuerelement gefüllt.<\/p>\n Listing 6: Die Beim Anzeigen-Ereignisprozedur des Unterformulars wird im Klassenmodul des Hauptformulars implementiert.<\/span><\/b><\/p>\n Dieses landet dann im zuvor instanzierten Collection<\/b>-Object colTextboxes<\/b>. Derweil kommt auch die zweite weiter oben deklarierte Array-Variable namens strArbeitstage <\/b>zum Zuge:<\/p>\n Dieses wird nämlich mit dem in der Tag<\/b>-Eigenschaft der Textfelder gespeicherten Datumswert für die aktuelle Spalte gefüllt.<\/p>\n Damit ist die Aufgabe der Prozedur sfm_Current<\/b> erfüllt – und die Vorbereitungen sind abgeschlossen.<\/p>\n Nun fehlen noch die Erläuterungen der Klasse clsTextbox<\/b>, welche die Kontextmenüs für die verschiedenen Textfelder bereitstellt, und der Prozedur, die durch das Betätigen eines Kontextmenü-Eintrags ausgelöst wird.<\/p>\n Die Klasse clsTextboxes<\/b><\/p>\n Jedes Textfeld soll mit einer Funktion versehen werden, die für die Anzeige eines benutzerdefinierten Kontextmenüs beim Anklicken mit der rechten Maustaste sorgt.<\/p>\n Dies erledigen wir, indem wir für jedes Textfeld ein Objekt auf Basis der Klasse clsTextbox <\/b>erstellen, welche beim Rechtsklick ein entsprechendes Ereignis auslöst und das Kontextmenü einblendet.<\/p>\n Die Instanzierung der 28 Objekte haben wir uns weiter oben bereits angesehen, nun folgen die Details zur Klasse. Diese verwendet eine privat deklarierte Eigenschaft namens m_Textbox<\/b>, um den Verweis auf das übergebene Textfeld zu speichern.<\/p>\n Die Variable ist mit dem Schlüsselwort With-Events <\/b>deklariert, damit wir in dieser Klasse auch die Ereignisse des Textfeldes implementieren können:<\/p>\n Damit die oben beschriebene Funktion sfm_Current <\/b>dem Objekt einen Verweis auf das Textfeld übergeben kann, definiert dieses eine entsprechende Property Set<\/b>-Prozedur, die wie folgt aussieht:<\/p>\n\n
Public Sub <\/span>ArbeitstageEintragen(Optional<\/span> datStart As Date<\/span>, Optional<\/span> datEnde As Date<\/span>)\r\n Dim <\/span>datAktuell As Date<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n If <\/span>datStart = 0 Then<\/span>\r\n datStart = Date\r\n End If<\/span>\r\n If <\/span>datEnde = 0 Then<\/span>\r\n datEnde = datStart + 1000\r\n End If<\/span>\r\n On Error Resume Next<\/span>\r\n For datAktuell = datStart To datEnde\r\n db.Execute \"INSERT INTO tblArbeitstage(Arbeitstag) VALUES(\" & ISODatum(datAktuell) & \")\", dbFailOnError\r\n Next<\/span> datAktuell\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2013_05\/pic_906_003.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2013_05\/pic_906_004.png\")
<\/p>\nPublic Sub <\/span>SchichtenEintragen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstMitarbeiter As <\/span>DAO.Recordset\r\n Dim <\/span>rstArbeitstage As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rstMitarbeiter = db.OpenRecordset(\"SELECT * FROM tblMitarbeiter\", dbOpenDynaset)\r\n Set<\/span> rstArbeitstage = db.OpenRecordset(\"SELECT * FROM tblArbeitstage\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstMitarbeiter.EOF\r\n Do While<\/span> Not<\/span> rstArbeitstage.EOF\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblSchichten(MitarbeiterID, ArbeitstagID) VALUES(\" & rstMitarbeiter!MitarbeiterID _\r\n & \", \" & rstArbeitstage!ArbeitstagID & \")\", dbFailOnError\r\n On Error GoTo<\/span> 0\r\n rstArbeitstage.MoveNext<\/span>\r\n Loop<\/span>\r\n rstArbeitstage.MoveFirst\r\n rstMitarbeiter.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Ergebnis](\"..\/fileadmin\/_temp_\/2013_05\/pic_906_005.png\")
<\/p>\n\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2013_05\/pic_906_002.png\")
<\/p>\n>=#01.08.2013# Und <#01.09.2013#<\/pre>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2013_05\/pic_906_007.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2013_05\/pic_906_008.png\")
<\/p>\n\n
>=[Startdatum] Und <[Enddatum]<\/pre>\n
Private Sub <\/span>KreuztabelleFuellen(dat As Date<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n strSQL = db.QueryDefs(\"qryCTSchichten\").SQL\r\n strSQL = Replace<\/span>(strSQL, \"[Startdatum]\", ISODatum(dat))\r\n strSQL = Replace<\/span>(strSQL, \"[Enddatum]\", ISODatum(DateAdd(\"d\", 28, dat)))\r\n Me!sfmSchichten.Form.RecordSource = strSQL\r\n For i = 0 To 27\r\n Me!sfmSchichten.Form(\"lbl\" & Format(i + 1, \"00\")).Caption = Format(DateAdd(\"d\", i, dat), \"d.m\")\r\n Me!sfmSchichten.Form(\"txt\" & Format(i + 1, \"00\")).ControlSource = Format(DateAdd(\"d\", i, dat), \"dd_mm_yyyy\")\r\n Me!sfmSchichten.Form(\"txt\" & Format(i + 1, \"00\")).Tag = DateAdd(\"d\", i, dat)\r\n Next<\/span> i\r\n SpaltenbreitenAnpassen\r\nEnd Sub<\/span><\/pre>\n\n
Private Sub <\/span>SpaltenbreitenAnpassen()\r\n Dim <\/span>ctl As <\/span>Control\r\n For Each ctl In Me!sfmSchichten.Form.Controls\r\n Select Case ctl.ControlType\r\n Case <\/span>acTextBox, acComboBox, acCheckBox\r\n If <\/span>Len<\/span>(ctl.ControlSource) > 0 Then<\/span>\r\n ctl.ColumnWidth = -2\r\n End If<\/span>\r\n Case Else<\/span>\r\n Debug.Print<\/span> ctl.ControlType, ctl.Name\r\n End Select<\/span>\r\n Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtStartdatum_AfterUpdate()\r\n KreuztabelleFuellen Me!txtStartdatum\r\nEnd Sub<\/span><\/pre>\n![\"Der](\"..\/fileadmin\/_temp_\/2013_05\/pic_906_009.png\")
<\/p>\nDim <\/span>colTextboxes As <\/span>Collection<\/pre>\nDim <\/span>WithEvents objDSF As <\/span> clsDatasheetSelectionForm\r\nDim <\/span>WithEvents sfm As <\/span>Form\r\nDim <\/span>strMitarbeiter() As String<\/span>\r\nDim <\/span>datArbeitstage(28) As Date<\/span><\/pre>\nPrivate Sub <\/span>Form_Load()\r\n KreuztabelleFuellen Date\r\n Set<\/span> objDSF = New<\/span> clsDatasheetSelectionForm\r\n With<\/span> objDSF\r\n Set<\/span> .Form = Me!sfmSchichten.Form\r\n End With<\/span>\r\n Set<\/span> sfm = Me!sfmSchichten.Form\r\n With<\/span> sfm\r\n .OnCurrent = \"[Event Procedure]\"\r\n End With<\/span>\r\n sfm_Current\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> rst = sfm.RecordsetClone\r\n Do While<\/span> Not<\/span> rst.EOF\r\n ReDim Preserve strMitarbeiter(rst.AbsolutePosition + 1)\r\n strMitarbeiter(rst.AbsolutePosition + 1) = rst!Mitarbeiter\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>sfm_Current()\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>objTextbox As <\/span>clsTextbox\r\n Set<\/span> colTextboxes = New<\/span> Collection\r\n For i = 1 To 28\r\n Set<\/span> objTextbox = New<\/span> clsTextbox\r\n With<\/span> objTextbox\r\n Set<\/span> .Textbox = sfm.Controls(\"txt\" & Format(i, \"00\"))\r\n datArbeitstage(i) = sfm.Controls(\"txt\" & Format(i, \"00\")).Tag\r\n End With<\/span>\r\n colTextboxes.Add objTextbox, \"txt\" & Format(i, \"00\")\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>WithEvents m_Textbox As <\/span>Textbox<\/pre>\n