<\/p>\n
Das Verwalten von Fehlzeiten bezieht sich auf Urlaub, Krankheit, Fortbildung et cetera und erfordert keine Wunderwerke der Datenmodellierung. Eine Tabelle mit Mitarbeitern, eine mit den Fehlzeiten – mehr benötigen Sie nicht. Interessant wird es jedoch, die Fehlzeiten einzugeben und diese übersichtlich darzustellen. Und zwar so, dass nicht nur die Fehlzeiten eines einzigen Mitarbeiters, sondern möglichst die aller Mitarbeiter sichtbar sind. Nur so lässt sich effektiv vorausplanen.<\/b><\/p>\n
Die Musterlösung dieses Beitrags soll es erlauben, mehrere Mitarbeiter zu verwalten und für jeden Tag Fehlzeiten in Form halber Tage festzuhalten – es kann ja durchaus geschehen, dass ein Mitarbeiter mal einen halben Tag Urlaub nimmt, an einer Fortbildung teilnimmt oder sich nach dem Mittagessen mit einer Magenverstimmung verabschiedet.<\/p>\n
Datenmodell<\/b><\/p>\n
Das Datenmodell besteht aus einer einfachen Mitarbeitertabelle und einer Tabelle zur Verwaltung von Abteilungen. Außerdem gibt es eine Tabelle zum Speichern der verschiedenen Arten von Fehlzeiten und eine zum Aufnehmen der Fehlzeiten selbst.<\/p>\n
Die Tabelle tblMitarbeiter <\/b>ist recht einfach gehalten und enthält neben dem Primärschlüsselfeld nur zwei Felder zur Angabe von Vor- und Nachname, ein Feld zum Eintragen einer Bezeichnung, die in der Regel die Form <Nachname>, <Vorname> <\/b>aufweist, und ein Nachschlagefeld zur Auswahl der Abteilung des Mitarbeiters (s. Bild 1). Die damit referenzierte Tabelle tblAbteilung <\/b>ist eine schlichte Lookup-Tabelle, die nur das Primärschlüsselfeld AbteilungID <\/b>sowie das Feld mit der Bezeichnung der Abteilung enthält.<\/p>\n
![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic004.png\")
<\/p>\n
Bild 3: Fehlzeiten werden jeweils als halbe Tage erfasst<\/span><\/b><\/p>\n Gleiches gilt für die Tabelle tblFehlzeitarten<\/b>, die nur aus den beiden Feldern FehlzeitartID <\/b>und Fehlzeitart <\/b>besteht. Sie nimmt in der aktuellen Version die drei Werte Krankheit<\/b>, Urlaub <\/b>und Weiterbildung <\/b>auf (s. Bild 2).<\/p>\n Bild 1: Die Tabelle tblMitarbeiter in der Entwurfsansicht<\/span><\/b><\/p>\n Fehlt noch die Tabelle tblFehlzeiten<\/b>, welche die tatsächlichen Fehlzeiten aufnimmt. Sie enthält ein Primärschlüsselfeld namens FehlzeitID<\/b> und ein Datumsfeld namens Fehlzeitdatum<\/b>. Weitere zwei Felder sind Fremdschlüsselfelder und referenzieren die Datensätze der Tabellen tblMitarbeiter<\/b> und tblFehlzeitarten<\/b>.<\/p>\n Fehlt noch eine wichtige Information, die davon abhängt, ob Sie nur ganze Fehltage aufnehmen möchten oder auch halbe Fehltage (man könnte dies natürlich auch stundenweise erledigen, aber wenn jemand zwei Stunden frei haben möchte, um mit seinem Kind zum Arzt zu gehen, hängt er die zwei Stunden halt irgendwo hinten an).<\/p>\n Wie aber bekommen wir die halben Fehltage in den Griff Bei einem ganzen Fehltag wäre dies kein Problem: Sie legen einen Eintrag in der Tabelle tblFehltage <\/b>an und der Fall ist erledigt. Bei halben Tagen brauchen wir aber zumindest noch ein weiteres Feld, mit dem wir die Fehlzeitdauer aufnehmen. Aber macht es Sinn, tatsächlich nur die Dauer, also einen Wert wie 1 oder 1\/2 zu speichern Vielleicht brauchen wir noch weitere Informationen, zum Beispiel, ob der halbe Tag vormittags oder nachmittags beziehungsweise die erste oder die zweite Hälfte der Schicht betrifft<\/p>\n Dies wird nämlich beispielsweise interessant, wenn immer eine bestimmte Anzahl Mitarbeiter gebraucht wird. Und auch für eine grafische Darstellung der Fehlzeiten wäre es sinnvoll, die Position des halben Fehltages anzeigen zu können. Welche Möglichkeiten haben wir nun<\/p>\n Wir entscheiden uns für die letzte Variante. Die Tabelle tblFehlzeiten<\/b> sieht somit wie in Bild 4).<\/p>\n Bild 2: Tabelle zum Speichern der Fehlzeitarten<\/span><\/b><\/p>\n Bild 4: Datenmodell der Musterlösung<\/span><\/b><\/p>\n Darstellung der Fehlzeiten im Formular<\/b><\/p>\n Für die Darstellung der Fehlzeiten gibt es mehrere Möglichkeiten. Grundsätzlich sollen die Spaltenköpfe die Datumsangaben enthalten und die Zeilenköpfe die Namen der Mitarbeiter. Die einzelnen Zellen erhalten dann eine die jeweilige Fehlzeitart repräsentierende Farbe (diese legen Sie übrigens in der Tabelle tblFehlzeitarten <\/b>fest – später lernen Sie ein Formular zur Bearbeitung der Fehlzeitarten kennen). Aber da wir uns nun schon darauf eingeschossen haben, auch halbtägige Fehlzeiten zu vergeben: Wie stellen wir diese in einer Übersicht wie oben beschrieben dar Eigentlich gibt es nur zwei Möglichkeiten: entweder die Fehlzeit am Vormittag landet oben und die am Nachmittag unten oder die Fehlzeiten werden links und rechts im Kasten für den jeweiligen Tag angezeigt. Für ganztägige Fehlzeiten wird der komplette Kasten mit der entsprechenden Farbe gefüllt.<\/p>\n Bild 5 zeigt, wie der zweite Vorschlag aussieht. Dieser ist die bessere Lösung, weil man die Fehlzeiten für den Vor- und den Nachmittag durch Prüfen einer einzigen Spalte überblicken kann. Diese Ansicht lässt sich mit Bordmitteln nicht realisieren. Zwar könnten Sie die Abwesenheiten aller Mitarbeiter untereinander mit einer ganzen Menge Steuerelemente und in der Endlosansicht anzeigen, aber wenn Sie wie in diesem Beispiel auch noch nach einer übergeordneten Kategorie wie etwa Abteilungen gruppieren möchten, haben Sie keine Chance. Daher stellen wir einmal dar, wie dies mit dem Webbrowser-Steuerelement und HTML funktioniert.<\/p>\n Bild 5: Formular zum Hinzufügen von Fehlzeiten<\/span><\/b><\/p>\n Wie werden die Fehlzeiten hinzugefügt oder entfernt Dazu enthält jedes einzelne Element in der Fehlzeitenübersicht ein Kontextmenü (s. Bild 6). Klicken Sie mit der rechten Maustaste auf den Tag für den entsprechenden Mitarbeiter und wählen Sie die gewünschte Fehlzeitart samt Dauer aus.<\/p>\n Bild 6: Fehlzeit per Kontextmenü<\/span><\/b><\/p>\n Formular anlegen<\/b><\/p>\n Das Formular sieht in der Entwurfsansicht wie in Bild 7 aus und enthält zunächst ein Webbrowser-Steuerelement. Dieses fügen Sie in den Access-Versionen bis Access 2007 als ActiveX-Steuerelement hinzu, ab Access 2010 verwenden Sie das eingebaute Webbrowser-Steuerelement.<\/p>\n Bild 7: Das Formular zur Anzeige der Fehlzeitenübersicht in der Entwurfsansicht<\/span><\/b><\/p>\n Das Webbrowser-Steuerelement soll den Namen ctlWebbrowser <\/b>erhalten.<\/p>\n Im Kopfbereich des Formulars finden Sie folgende Steuerelemente:<\/p>\n Füllen des Webbrowser-Steuerelements<\/b><\/p>\n Die aufwendigste Aufgabe dieser Beispielanwendung ist natürlich das Füllen des Webbrowser-Steuerelements. Dies erledigt die Prozedur FehlzeitenAnzeigen<\/b> – mehr dazu weiter unten.<\/p>\n Diese Prozedur wird zu verschiedenen Gelegenheiten aufgerufen, als Erstes natürlich beim Anzeigen des Formulars – hier in der Prozedur, die durch das Ereignis Beim Laden <\/b>ausgelöst wird:<\/p>\n Diese Prozedur leistet allerdings noch ein wenig Vorarbeit: Sie ermittelt mit der Date<\/b>-Funktion das aktuelle Datum und daraus mit der Funktion MontagDerWoche<\/b> den Montag der Woche, in der das Datum liegt:<\/p>\n MontagDerWoche <\/b>holt sich mit der Weekday<\/b>-Funktion eine Zahl, welche den Tag der Woche repräsentiert, also beispielsweise den Wert 3<\/b>, wenn der Tag von Date <\/b>ein Mittwoch ist (Montag entspricht 1<\/b>). Um den Montag der Woche zu ermitteln, in der sich das aktuelle Datum befindet, muss man nur noch die Differenz der Tage vom Montag bis zum aktuellen Tag ermitteln und vom aktuellen Tag abziehen.<\/p>\n Dieses Datum trägt Form_Load <\/b>in das Textfeld txtStart <\/b>ein und ruft dann die Prozedur FehlzeitenAnzeigen <\/b>auf. Die Prozedur wird auch aufgerufen, wenn der Benutzer eine der beiden Schaltflächen cmdNaechsteWoche <\/b>oder cmdVorherigeWoche <\/b>anklickt. Die dadurch ausgelösten Prozeduren fügen entweder sieben Tage zum Datum im Textfeld txtStart <\/b>hinzu oder ziehen diese ab, um den Startzeitpunkt der Fehlzeitenanzeige um eine Woche nach vorn oder hinten zu verschieben:<\/p>\n Das Anklicken der Schaltfläche cmdFuellen <\/b>dient allein der Aktualisierung der Anzeige:<\/p>\n Außerdem wird die Anzeige noch nach dem Bearbeiten der anzuzeigenden Mitarbeiter und der Fehlzeitarten aktualisiert – mehr dazu weiter unten.<\/p>\n Die Prozedur FehlzeitenAnzeigen<\/b><\/p>\n Diese Prozedur, die Sie im Klassenmodul des Formulars frmFehlzeiten <\/b>finden (und in Listing 1<\/a><\/span>), bildet das Grundgerüst zum Füllen der Fehlzeiten-Übersicht. Einige weitere Prozeduren übernehmen die Kleinarbeit wie das Anlegen und Ausstatten der einzelnen Tabellenelemente wie Zeilen, Zellen, in Zellen enthaltene Tabellen und so weiter.<\/p>\n Listing 1: Füllen des Webbrowser-Steuerelements<\/p>\n Im Deklarationsteil finden Sie unter anderem zwei Recordset-Objekte, mit denen erst die Abteilungen und dann die Mitarbeiter der Abteilungen durchlaufen werden, und außerdem einige HTML-Objekte.<\/p>\n Danach folgt direkt die Instanzierung eines Collection-Objekts, das im Kopf des Klassenmoduls des Formulars deklariert wird:<\/p>\n Wozu das Jeder Tag soll ja zwei Zellen enthalten, die nach einem Mausklick ein Kontextmenü anzeigen. Dies gelingt nur, wenn Sie eine entsprechende Ereignisprozedur für die entsprechenden HTMLTableCell<\/b>-Elemente anlegen. Nun wäre es aber ein wahnsinniger Aufwand, vorab für viele hundert HTMLTableCell<\/b>-Elemente Ereignisprozeduren anzulegen.<\/p>\n Daher verwenden wir eine kleine Wrapper-Klasse, der wir einen Bezug auf das jeweilige HTMLTableCell<\/b>-Element mitgeben. Diese Wrapper-Klasse enthält die für die Anzeige des Kontextmenüs nötigen Ereignisprozeduren. Vorteil: Sie brauchen die Klasse nur einmal zu programmieren und können sie für jedes der Kalender-Elemente, das ein Kontextmenü anzeigen soll, neu instanzieren.<\/p>\n Wie das genau funktioniert, erfahren Sie weiter unten. An dieser Stelle ist erstmal wichtig, dass es eine Collection gibt, welche Verweise auf alle Instanzen der Wrapper-Klasse aufnimmt, damit diese nach dem Erzeugen nicht im Nirwana verschwinden.<\/p>\n Abteilungen durchlaufen<\/b><\/p>\n Das Recordset rstAbteilungen<\/b> basiert auf einer Abfrage, die nicht alle Abteilungen der Tabelle tblAbteilungen<\/b> zurückliefert, sondern nur diejenigen, die mindestens einen Mitarbeiter enthalten. Die dabei verwendete Abfrage qryAbteilungenMitMitarbeitern <\/b>sieht wie in Bild 8 aus. Die Abfrage gibt zwar nur Felder der Tabelle tblAbteilungen <\/b>zurück, aber dadurch, dass diese in der Abfrage mit der Tabelle tblMitarbeiter <\/b>verknüpft ist, werden die Datensätze ohne Bezug zu einem Mitarbeiter-Datensatz ignoriert.<\/p>\n Bild 8: Abfrage zur Ermittlung aller Abteilungen mit mindestens einem Mitarbeiter<\/span><\/b><\/p>\n Danach liefert die Funktion DokumentHolen <\/b>einen Verweis auf ein HTML-Dokument, das innerhalb dieser Funktion erstellt wird:<\/p>\n Die Funktion verwendet zunächst eine weitere Funktion namens GetWebbrowser<\/b>, um eine Referenz auf das im Formular enthaltene Webbrowser-Steuerelement zu erhalten. Diese wird nach dem Erstellen in der modulweit deklarierten Variablen gespeichert:<\/p>\n Die Funktion GetWebbrowser <\/b>prüft, ob m_Webbrowser <\/b>schon gefüllt ist, und holt dies gegebenenfalls nach. In jedem Fall gibt GetWebbrowser <\/b>einen Verweis auf dieses Steuerelement zurück:<\/p>\n Die Funktion DokumentHolen <\/b>lädt dann zunächst eine leere Seite (about:blank<\/b>) und wartet, bis diese Seite geladen ist. Wichtig ist der vorherige Aufruf der DoEvents<\/b>-Anweisung, da das Webbrowser-Steuerelement sonst gegebenenfalls noch nicht bereit ist. Danach gibt die Funktion den Verweis auf das HTMLDocument<\/b>-Objekt zurück.<\/p>\n Haupttabelle erstellen<\/b><\/p>\n Die Funktion TabelleErstellen <\/b>erzeugt dann die Tabelle, die alle anderen Elemente enthält, und liefert diese an die Objektvariable objTable <\/b>zurück. Als Parameter erwartet diese Prozedur einen Verweis auf das HTMLDocument<\/b>-Objekt:<\/p>\n Die Prozedur erstellt ein neues HTMLTable<\/b>-Element im Kontext des HTMLDocument<\/b>-Objekts und hängt dieses dann an das HTMLDocument<\/b>-Objekt an, sodass es Teil des Dokuments wird. Außerdem stellt es einige Schrift-Eigenschaften ein und legt mit borderCollapse <\/b>fest, dass die Rahmen zweier benachbarter Tabellenzellen miteinander verschmelzen sollen.<\/p>\n Spaltenköpfe erstellen<\/b><\/p>\n Wir haben nun ein Tabellen-Objekt, das wir mit einigen Zeilen ausstatten wollen. Die erste Zeile soll die Spaltenköpfe, also die Datumsangaben anzeigen, weshalb wir dieser Spalte 28 Zellen für je einen Tag zuweisen. Vorher werden jedoch noch zwei leere Zellen eingefügt, weil die folgenden Zeilen auch zwei Zellen zur Anzeige der Mitarbeiternamen und zum Herstellen eines Abstands zwischen Mitarbeiternamen und den Zellen zur Anzeige der Fehlzeiten enthalten (Bild 9 veranschaulicht die beiden leeren Zellen).<\/p>\n Bild 9: Zwei leere Zellen in der Zeile mit den Spaltenköpfen<\/span><\/b><\/p>\n Danach durchläuft eine Schleife 28 Tage ausgehend von dem im Textfeld txtStart <\/b>angegebenen Tag. Der aktuelle Tag wird dabei in der Laufvariablen datAktuell <\/b>gespeichert. Innerhalb der Schleife wird lediglich die Prozedur ZelleTagAnlegen <\/b>aufgerufen (siehe Listing 2<\/a><\/span>). Die Prozedur ermittelt zunächst per DLookup<\/b>-Anweisung, mit welcher Farbe der aktuelle Tag hinterlegt werden soll, und wandelt den Farbwert in ein Format um, das mit HTML dargestellt werden kann (die dazu verwendeten Funktionen finden Sie im Modul mdlTools<\/b>).<\/p>\n Listing 2: Zelle für die Spaltenüberschrift mit Datum anlegen<\/p>\n <\/p>\n Dann fügt die insertCell<\/b>-Methode eine neue Zelle zu der mit objRow <\/b>referenzierten Zeile hinzu. Diese Zellen werden mit einer entsprechenden Schriftart, Ausrichtung, Textabstand und Breite ausgestattet und schließlich mit dem aktuellen Datum im Format ddd.dd.mm <\/b>gefüllt, allerdings werden der abgekürzte Tag (ddd.<\/b>) und der Rest (dd.mm.<\/b>) durch einen Zeilenumbruch (<br><\/b>) voneinander getrennt.<\/p>\n Sollte es sich bei dem Tag um einen Samstag oder Sonntag handeln (Weekday <\/b>liefert dann 6 <\/b>oder 7<\/b>), wird die Schrift noch fett gesetzt und ein grauer Hintergrund eingestellt. Schließlich stellt die Prozedur noch die zuvor ermittelte Hintergrundfarbe ein, falls die Spaltenüberschrift das aktuelle Datum darstellt.<\/p>\n Damit hätten wir nun eine Tabelle mit einer ersten Zeile, welche die Spaltenüberschriften enthält, in diesem Fall die Datumsangaben.<\/p>\n Danach folgt das verschachtelte Durchlaufen zweier Do While<\/b>-Schleifen. Die erste behandelt alle Einträge des Recordsets rstAbteilungen<\/b>, die zweite alle Mitarbeiter, die in der Übersicht angezeigt werden sollen.<\/p>\n Das sind nicht unbedingt alle – mit der Lösung des Beitrags 1:n-Beziehung mit HTML <\/b>(www.access-im-unternehmen.de\/851<\/b>) wählen Sie nämlich die anzuzeigenden Mitarbeiter aus. Dabei werden diese Mitarbeiter in der Tabelle tblMitarbeiterAnzeigen<\/b> gespeichert (s. Bild 10).<\/p>\n Bild 11: Ermittlung aller anzuzeigenden Mitarbeiter für die aktuelle Abteilung<\/span><\/b><\/p>\n Dementsprechend berücksichtigt das Recordset rstMitarbeiter <\/b>nicht nur die in der übergeordneten Schleife aktive Abteilung, sondern auch noch die Tabelle tblMitarbeiterAnzeigen<\/b>. Wer zur aktuellen Abteilung gehört und auch noch angezeigt werden soll, wird mit der Abfrage qryAusgewaehlteMitarbeiter <\/b>ermittelt (s. Bild 11).<\/p>\n Bild 10: Diese Tabelle legt fest, welche Mitarbeiter in der Fehlzeitenübersicht erscheinen sollen.<\/span><\/b><\/p>\n Abteilungsüberschriften anlegen<\/b><\/p>\n Die OpenRecordset<\/b>-Methode filtert diese Abfrage noch nach der AbteilungID <\/b>des Recordsets rstAbteilungen<\/b>. Innerhalb dieser beiden Schleifen geschieht nun eine ganze Menge. Bevor die Schleife über die Mitarbeiter der Abteilung startet, fügt die Prozedur ZeileAbteilungEinfuegen<\/b> zunächst eine Zeile zur Tabelle hinzu, welche sich über die komplette Spalte erstreckt. Dabei erhält die Prozedur einen Verweis auf das HTMLTable<\/b>-Objekt sowie die Bezeichnung der Abteilung als Parameter. Im Gegensatz zu den Zeilen mit den Spaltenüberschriften und den Mitarbeitern\/Fehltagen soll diese Zeile nur eine einzige Zelle enthalten. Deshalb legt die Prozedur zunächst eine Zeile an (HTMLTableRow<\/b>) und dann eine einzige Zelle (HTMLTableCell<\/b>). Normalerweise würde diese Zelle ihre Breite an der Breite der Zellen der übrigen Zeilen ausrichten. Die Prozedur legt aber für die Eigenschaft colSpan <\/b>der Zelle den Wert 30 <\/b>fest, was bedeutet, dass sich die Zelle über 30 Zellen der übrigen Zeilen erstreckt – also über die gesamte Breite (eine Zelle mit der Mitarbeiterbezeichnung, eine Zelle als Platzhalter und 28 Zellen für die einzelnen Tage).<\/p>\n Erst nach dem Anlegen der Überschrift für die Abteilung folgt die innere Schleife über alle Mitarbeiter dieser Tabelle.<\/p>\n Mitarbeiter anlegen<\/b><\/p>\n Die erste Zeile erstellt durch einen Aufruf der Funktion ZeileMitMitarbeiterEinfuegen <\/b>eine neue Zeile in der Tabelle. Die Funktion erwartet das HTMLTable<\/b>-Objekt und liefert einen Verweis auf eine neue, leere Zeile zurück. Diese wurde lediglich mit einigen Eigenschaften für Höhe, Rahmenbreite und Abstand ausgestattet:<\/p>\n Mitarbeitername einfügen<\/b><\/p>\n Mit dieser in der Variablen objRow <\/b>gespeicherten Zeile geht es in die nächste Prozedur namens ZeilenkopfMitarbeiterEinfuegen<\/b>, die außerdem den anzuzeigenden Mitarbeiternamen entgegennimmt. Sie legt ein neues HTMLTableCell<\/b>-Objekt an und füllt es mit dem Namen des Mitarbeiters sowie Informationen zur Schriftart. Auch die Platzhalter-Zelle mit der Breite von 10 Pixeln wird hier angelegt:<\/p>\n Kalenderelemente einfügen<\/b><\/p>\n Nun folgt das Raster zum Aufnehmen je einer Zelle pro Tag und Mitarbeiter. Dazu wird erneut eine Schleife über 28 Tage durchlaufen. Jedes Kalenderelement besteht nicht nur aus einer einfachen Zelle. Diese Zelle soll ja gegebenenfalls unterschiedliche Hintergrundfarben auch für halbe Fehlzeit-Tage anzeigen. Also muss jede Zelle wiederum zwei Zellen enthalten. Diese können Sie unter HTML jedoch nicht direkt in eine Zelle einfügen. Stattdessen legen Sie in jeder der Zellen für einen Tag eine Tabelle mit einer Zeile und den zwei benötigten Zellen an.<\/p>\n All dies und mehr erledigt die Funktion ZelleTagMitarbeiterHinzufuegen<\/b>, die das aktuelle Datum, einen Verweis auf die Zeile für den Mitarbeiter (HTMLTableRow<\/b>), die MitarbeiterID <\/b>des Mitarbeiters sowie einen Verweis auf das HTMLDocument<\/b>-Objekt erwartet (s. Listing 3<\/a><\/span>).<\/p>\n Listing 4: Hinzufügen einer Tabelle zur Fehlzeiten-Zelle<\/p>\n Die Prozedur legt zunächst eine neue Zelle in der referenzierten Zeile an (dies entspricht dann neben der Zelle mit dem Mitarbeiternamen und der als Platzhalter erstellten Zelle der dritten Zelle der Zeile). Falls das übergebene Datum auf einen Samstag oder Sonntag fällt, wird der Hintergrund grau gefärbt. Dann erhält die Zelle einige Attribute. Das Attribut id <\/b>wird auf den Tag eingestellt, also beim 31.1.2012 <\/b>etwa auf 31<\/b>. Außerdem legt die Prozedur zwei benutzerdefinierte Attribute an, nämlich Datum <\/b>(wird mit dem Long<\/b>-Wert für das Datum gefüllt) und MitarbeiterID <\/b>(erhält den Wert von lngMitarbeiter<\/b>).<\/p>\n An dieser Stelle kommt nun die bereits erwähnte Wrapper-Klasse clsTableCell <\/b>ins Spiel. Diese wird für jede in dieser Funktion hinzugefügte Zelle erstellt und mit einem Verweis auf das HTMLTableCell<\/b>-Objekt gefüllt. Das so erzeugte Objekt objTableCell <\/b>wird am Ende der Prozedur auch als Rückgabewert der Funktion festgelegt.<\/p>\n Zwischendurch ruft die Funktion jedoch noch eine weitere Prozedur namens TabelleTagMitarbeiterHinzufuegen <\/b>auf (s. Listing 4<\/a><\/span>). Diese Prozedur erstellt ein neues HTMLTable<\/b>-Element und fügt es in die soeben erstellte Zelle ein. Dies ist die Voraussetzung, damit wir noch ein HTMLTableRow<\/b>-Objekt und darin die beiden HTMLTableCell<\/b>-Objekt zum Anzeigen der beiden Fehlzeiten-Hälften für einen Tag hinzufügen können.<\/p>\n Listing 5: Hinzufügen einer Zeile in die Tabelle der Fehlzeiten-Zelle<\/p>\n Von hier aus geht es gleich weiter zur Prozedur ZeileTagMitarbeiterHinzufuegen<\/b>, welche auf ähnliche Weise das HTMLTableRow<\/b>-Element hinzufügt (s. Listing 5<\/a><\/span>). Nach dem Hinzufügen der Zeile fehlen nur die beiden HTMLTableCell<\/b>-Elemente, die schließlich mit der Funktion InnereZelleTagMitarbeiterHinzufuegen <\/b>zu der per Parameter übergebenen Zeile hinzugefügt werden (s. Listing 6<\/a><\/span>).<\/p>\n Listing 6: Hinzufügen einer Zelle zur Zeile der Tabelle der Fehlzeiten-Zelle<\/p>\n Diese Funktion hat wiederum einen Rückgabewert, mit dem die beiden Eigenschaften cellRight <\/b>und cellLeft <\/b>der Wrapper-Klasse clsTableCell <\/b>gefüllt werden – mehr dazu später. Auf diese Weise werden für alle Mitarbeiter je 28 Zellen mit je einer Tabelle, einer Zeile und zwei weiteren Zellen zur Markierung der Fehlzeiten hinzugefügt.<\/p>\n Wrapper-Klasse merken<\/b><\/p>\n Nicht vergessen werden darf die folgende Zeile der Prozedur FehlzeitenAnzeigen<\/b>:<\/p>\n Diese speichert die Wrapper-Klasse für die aktuelle Zelle in der Collection colTableCells<\/b>. Interessant dabei ist, dass dort auch ein Schlüssel übergeben wird, der durch ein Pipe-Zeichen (|<\/b>) aus der MitarbeiterID <\/b>und dem als Long<\/b>-Wert konvertierten Datum zusammengesetzt wird (zum Beispiel 9|41087<\/b>). Auf diese Weise können Sie später per Code auf alle Elemente der Matrix zugreifen.<\/p>\n Fehlzeiten eintragen<\/b><\/p>\n Damit wäre der Fehlzeitenplan fast fertig, wenn nicht noch das Wichtigste fehlen würde: die Markierung der Fehlzeiten. Dies erledigt die Prozedur FehlzeitenEintragen<\/b>, die jedoch noch weitere Hilfsfunktionen aufruft (s. Listing 7<\/a><\/span>).<\/p>\n Listing 7: Eintragen der Fehlzeiten<\/p>\n Die Prozedur erwartet das erste und das letzte Datum der Übersicht als Parameter. Sie erstellt eine Datensatzgruppe auf Basis der Abfrage qryFehlzeitenUndFarben<\/b>, welche alle Fehlzeiten liefert sowie die jeweiligen Farbcodes (s. Bild 12).<\/p>\n Bild 12: Diese Abfrage ermittelt die Fehlzeiten aller Mitarbeiter inklusive Farbe<\/span><\/b><\/p>\n Für die Datensatzgruppe wird diese Abfrage noch nach dem Zeitraum gefiltert. Beim Durchlaufen dieses Recordsets in einer Do While<\/b>-Schleife ermittelt die Prozedur zunächst den Hex-Wert für den Farbcode und trägt die Fehlzeitart <\/b>in die Variable strFehlzeitart <\/b>ein. Schließlich ruft sie eine weitere Prozedur namens FehlzeitEintragen<\/b> mit den Werten des Recordsets als Parameter auf.<\/p>\n Eine Fehlzeit eintragen<\/b><\/p>\n Die Prozedur FehlzeitEintragen <\/b>aus Listing 8<\/a><\/span> markiert die Fehlzeiten in der Fehlzeitenübersicht. Dazu könnte man normalerweise alle Zellen durchlaufen und jeweils prüfen, ob für den Mitarbeiter am entsprechenden Tag eine Fehlzeit vorliegt. Wir gehen jedoch einen Weg, der etwas pfiffiger programmiert ist und weniger Rechenaufwand bedeutet.<\/p>\n Listing 8: Eintragen einer Fehlzeit<\/p>\n Die Prozedur verwendet den Key <\/b>der Collection colTableCells<\/b>, um über die MitarbeiterID <\/b>und den Long<\/b>-Wert des Datums auf die Instanz der Wrapper-Klasse zuzugreifen, die den entsprechenden Mitarbeiter\/Tag repräsentiert:<\/p>\n Mit der Eigenschaft cellLeft <\/b>der Wrapper-Klasse erhalten wir einen Verweis auf die linke Zelle für den Mitarbeiter\/Tag und können, wenn die Variable intVormittag<\/b> den Wert -1 <\/b>hat, den Hintergrund der Zelle entsprechend der Farbe für die Fehlzeit einstellen.<\/p>\n Anderenfalls holt die Prozedur eine Referenz auf die rechte Zelle und färbt diese entsprechend ein.<\/p>\n Außerdem legt die Prozedur die Eigenschaft Title <\/b>des HTMLTableCell<\/b>-Objekts noch auf die Bezeichnung der Fehlzeit ein. Auf diese Weise brauchen Sie nur mit der Maus über die Fehlzeit zu fahren und sehen die Bezeichnung der Fehlzeit (s. Bild 13).<\/p>\n Bild 13: Fehlzeitmarkierung mit Bezeichnung<\/span><\/b><\/p>\n Die Klasse clsTableCell<\/b><\/p>\n Wozu benötigen wir die Wrapper-Klasse clsTableCell<\/b> Damit wir einen Aufbewahrungsort für jeweils einen Verweis auf eine Zelle in der Datum\/Mitarbeiter-Matrix haben. Dieser Aufbewahrungsort stellt aber zusätzlich Ereignisprozeduren bereit, sodass jede individuelle Zelle ein Kontextmenü in Abhängigkeit vom Datum und vom Mitarbeiter anzeigen kann. Die Klasse enthält zunächst drei Variablen, die später mit Verweisen auf die Hauptzelle, auf die linke Teilzelle und die rechte Teilzelle gefüllt werden:<\/p>\n Weiter oben haben Sie bereits gesehen, wie die drei Eigenschaften cell<\/b>, celLeft <\/b>und cellRight <\/b>von anderen Prozeduren aus gefüllt werden. Damit Sie diese Eigenschaften der Klasse füllen können, benötigen Sie entsprechende Property Set<\/b>-Methoden. Die für die Eigenschaft cell <\/b>sieht etwa so aus:<\/p>\n Die Prozedur nimmt einen Verweis auf das Objekt objCell <\/b>entgegen und speichert diesen in der oben aufgeführten Variablen m_Cell<\/b>. Diese wurde als WithEvents <\/b>deklariert, also mit Ereignissen. Mit der Eigenschaft oncontextmenu <\/b>legen Sie dann fest, dass beim Anklicken des HTMLTableCell<\/b>-Elements im Klassenmodul clsTableCell<\/b> nach einer entsprechenden Ereignisprozedur gesucht werden soll. Bei dieser Gelegenheit ist zu erwähnen, dass allein das Vorhandensein eines speziellen Ereignisses für das Aufrufen des Kontextmenüs eine angenehme Sache ist. Auf die entsprechende Ereignisprozedur kommen wir gleich im Anschluss. Zunächst noch die Definition der Property Set<\/b>-Prozeduren für die übrigen beiden Elemente:<\/p>\n Diese Prozeduren nehmen also nur die Verweise auf die beiden in der Hauptzeile für den Mitarbeiter\/Tag enthaltenen Zellen für die erste und die zweite Tageshälfte entgegen.<\/p>\n Schließlich werden zumindest die in den Eigenschaften m_CellLeft<\/b> und m_CellRight <\/b>gespeicherten Verweise von anderen Prozeduren abgefragt. Dafür stehen diese beiden Property Get<\/b>-Prozeduren bereit:<\/p>\n Kontextmenü zusammenstellen<\/b><\/p>\n Nun kommen wir zu der Prozedur, die beim Rechtsklick auf eine der Mitarbeiter\/Datum-Zellen ausgelöst wird (s. Listing 9<\/a><\/span>). Die Prozedur soll für jeden Datensatz der Tabelle tblFehlzeitart <\/b>drei Einträge anzeigen, und zwar zum Hinzufügen der Fehlzeit zum Vormittag, zum Nachmittag oder zum kompletten Tag.<\/p>\n Listing 9: Anzeigen des Kontextmenüs<\/p>\n Bevor das Kontextmenü erstellt wird, löscht die Prozedur zunächst ein eventuell noch vorhandenes Kontextmenü namens cbrCell<\/b>. Danach liest die Prozedur die ID des Mitarbeiters, zu dem die Zelle gehört, aus dem Attribut MitarbeiterID <\/b>des HTMLTableCell<\/b>-Objekts ein. Danach wird der CommandBars<\/b>-Auflistung mit der Add<\/b>-Methode ein neues Kontextmenü hinzugefügt.<\/p>\n Anschließend öffnet die Prozedur eine Datensatzgruppe mit allen Fehlzeitarten der Tabelle tblFehlzeitarten<\/b> und durchläuft diese in einer Do While<\/b>-Schleife. Innerhalb dieser Schleife legt die Prozedur jeweils einen neuen Eintrag im Kontextmenü an, der aus dem Namen der Fehlzeitart sowie den Zusätzen (kompletter Tag)<\/b>, (Vormittag) <\/b>und (Nachmittag) <\/b>besteht. Der onAction<\/b>-Eigenschaft dieser Einträge weist die Prozedur einen Ausdruck wie diesen zu:<\/p>\n Die erste Zahl steht für das Datum, die zweite für die MitarbeiterID<\/b>, die dritte für die FehlzeitartID<\/b> und die vierte für die Dauer (1 <\/b>entspricht dem kompletten Tag, -1 <\/b>dem Vormittag und 0 <\/b>dem Nachmittag).<\/p>\n Nach dem Durchlaufen der Schleife für alle Fehlzeitarten legt die Prozedur noch ein Element im Kontextmenü an, mit dem alle Fehlzeiten für den angeklickten Tag entfernt werden können. Schließlich sorgt die Methode ShowPopup <\/b>des CommandBar<\/b>-Objekts für die Anzeige des Kontextmenüs.<\/p>\n Auf Kontextmenü-Befehle reagieren<\/b><\/p>\n Fehlt noch die für die Kontextmenü-Einträge angegebene Prozedur FehlzeitHinzufuegen<\/b>. Diese Prozedur wird zwar durch einen Kontextmenü-Eintrag eines Elements der Klasse clsTableCell <\/b>ausgelöst, aber die Funktion, die für die Eigenschaft onAction <\/b>ausgelöst werden soll, können Sie nur in ein Standardmodul oder in das Klassenmodul des Formulars eintragen, das beim Aufrufen des Kontextmenüs den Fokus hat. Also fügen Sie die Prozedur aus Listing 10<\/a><\/span> dem Klassenmodul des Formulars frmFehlzeiten <\/b>hinzu.<\/p>\n Listing 10: Hinzufügen von Fehlzeiten<\/p>\n Diese Funktion ermittelt zunächst mit zwei Aufrufen der DLookup<\/b>-Funktion die Bezeichnung der Fehlzeitart sowie die Farbe dieser Fehlzeitart und speichert diese in entsprechenden Variablen.<\/p>\n Danach prüft sie, welchen Wert der Parameter intTageszeit <\/b>erhalten hat. 1 <\/b>steht für den kompletten Tag, -1 <\/b>für den Vormittag und 0 <\/b>für den Nachmittag. Im Falle des Wertes 1 <\/b>muss die Prozedur der Tabelle tblFehlzeiten <\/b>zwei Datensätze hinzufügen – einen für die Fehlzeit am Vormittag und eine für den Nachmittag. Zuvor jedoch müssen die bestehenden Fehlzeiten für den aktuellen Mitarbeiter und das aktuelle Datum gelöscht werden, was eine entsprechende DELETE<\/b>-Anweisung erledigt. Danach legt die Prozedur in einer For…Next<\/b>-Schleife über die Werte von -1 <\/b>bis 0 <\/b>die beiden neuen Fehlzeiten für diesen Tag an. Warum eine solche Schleife Weil die in der Schleife enthaltenen Anweisungen den gleichen Datensatz einmal für den Wert 0 <\/b>(False<\/b>) im Feld Vormittags <\/b>und einmal für den Wert -1 <\/b>(True<\/b>) durchführen.<\/p>\n Die enthaltenen Befehle rufen jeweils einmal eine INSERT INTO<\/b>-Anweisung zum Anlegen der Fehlzeit in der Tabelle tblFehlzeiten <\/b>und anschließend die Prozedur FehlzeitEintragen <\/b>auf, damit die neue Fehlzeit auch in der Fehlzeiten-Übersicht zu sehen ist.<\/p>\n Der zweite Teil der Select Case<\/b>-Anweisung wird angesteuert, wenn intTageszeit <\/b>den Wert -1 <\/b>oder 0 <\/b>enthält, also entweder nur der Vormittag oder nur der Nachmittag von der Fehlzeit betroffen ist.<\/p>\n In diesem Fall löscht die Prozedur ebenfalls die Fehlzeiten für den übergebenen Mitarbeiter und das Datum, legt allerdings nur für den Vormittag oder nur für den Nachmittag eine neue Fehlzeit an – je nach dem Wert von intTageszeit<\/b>, der schlicht in das Feld Vormittags <\/b>der Tabelle tblFehlzeiten <\/b>eintragen wird. Auch hier wird die Fehlzeit noch in die Fehlzeiten-Übersicht eingetragen.<\/p>\n Entfernen einer Fehlzeit<\/b><\/p>\n![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic001.png\")
<\/p>\n\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic002.png\")
<\/p>\n![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic005.png\")
<\/p>\n![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic007.png\")
<\/p>\n![\"pic009.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic009.png\")
<\/p>\n![\"pic008.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic008.png\")
<\/p>\n\n
Private Sub Form_Load()\r\n Dim datMontag As Date\r\n datMontag = MontagDerWoche(Date)\r\n Me!txtStart = datMontag\r\n FehlzeitenAnzeigen\r\nEnd Sub<\/pre>\n
Public Function MontagDerWoche(dat As Date) As Date\r\n Dim intWeekday As Integer\r\n intWeekday = Weekday(dat, vbMonday)\r\n MontagDerWoche = DateAdd("d", -(intWeekday - 1), dat)\r\nEnd Function<\/pre>\nPrivate Sub cmdNaechsteWoche_Click()\r\n Me!txtStart = Me!txtStart + 7\r\n FehlzeitenAnzeigen\r\nEnd Sub\r\nPrivate Sub cmdVorherigeWoche_Click()\r\n Me!txtStart = Me!txtStart - 7\r\n FehlzeitenAnzeigen\r\nEnd Sub<\/pre>\n
Private Sub cmdFuellen_Click()\r\n FehlzeitenAnzeigen\r\nEnd Sub<\/pre>\n
Private Sub FehlzeitenAnzeigen()\r\n Dim objDocument As MSHTML.HTMLDocument\r\n Dim db As DAO.Database\r\n Dim rstMitarbeiter As DAO.Recordset\r\n Dim rstAbteilungen As DAO.Recordset\r\n Dim datAktuell As Date\r\n Dim objTable As MSHTML.HTMLTable\r\n Dim objRow As MSHTML.HTMLTableRow\r\n Set colTableCells = New Collection\r\n Set db = CurrentDb\r\n Set rstAbteilungen = db.OpenRecordset("SELECT * FROM qryAbteilungenMitMitarbeitern", dbOpenDynaset)\r\n Set objDocument = DokumentHolen\r\n Set objTable = TabelleErstellen(objDocument)\r\n Set objRow = objTable.insertRow\r\n objRow.insertCell\r\n objRow.insertCell\r\n For datAktuell = Me!txtStart To DateAdd("d", 27, Me!txtStart)\r\n ZelleTagAnlegen datAktuell, objRow\r\n Next datAktuell\r\n Do While Not rstAbteilungen.EOF\r\n ZeileAbteilungEinfuegen objTable, rstAbteilungen!Abteilung\r\n Set rstMitarbeiter = db.OpenRecordset("SELECT * FROM qryAusgewaehlteMitarbeiter " _\r\n & "WHERE AbteilungID = " & rstAbteilungen!AbteilungID, dbOpenDynaset)\r\n Do While Not rstMitarbeiter.EOF\r\n Set objRow = ZeileMitarbeiterEinfuegen(objTable)\r\n ZeilenkopfMitarbeiterEinfuegen objRow, rstMitarbeiter!Bezeichnung\r\n For datAktuell = Me!txtStart To DateAdd("d", 27, Me!txtStart)\r\n Set objTableCell = ZelleTagMitarbeiterHinzufuegen(datAktuell, objRow, _\r\n rstMitarbeiter!MitarbeiterID, objDocument)\r\n colTableCells.Add objTableCell, CLng(rstMitarbeiter!MitarbeiterID) & "|" _\r\n & CLng(datAktuell)\r\n Next datAktuell\r\n rstMitarbeiter.MoveNext\r\n Loop\r\n rstAbteilungen.MoveNext\r\n Loop\r\n FehlzeitenEintragen Me!txtStart, DateAdd("d", 27, Me!txtStart)\r\nEnd Sub<\/pre>\nDim colTableCells As Collection<\/pre>\n
![\"pic010.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic010.png\")
<\/p>\nPrivate Function DokumentHolen() As MSHTML.HTMLDocument\r\n Dim objWebbrowser As SHDocVw.WebBrowser\r\n Dim objDocument As MSHTML.HTMLDocument\r\n Set objWebbrowser = GetWebbrowser\r\n DoEvents\r\n objWebbrowser.Navigate "about:blank"\r\n Do\r\n DoEvents\r\n Loop Until objWebbrowser.ReadyState = READYSTATE_COMPLETE\r\n Set objDocument = objWebbrowser.Document\r\n Set DokumentHolen = objDocument\r\nEnd Function<\/pre>\n
Dim WithEvents m_Webbrowser As WebBrowser<\/pre>\n
Private Function GetWebbrowser() As SHDocVw.WebBrowser\r\n If m_Webbrowser Is Nothing Then\r\n Set m_Webbrowser = _\r\n Me!ctlWebbrowser.Object\r\n End If\r\n Set GetWebbrowser = m_Webbrowser\r\nEnd Function<\/pre>\n
Private Function TabelleErstellen(objDocument As MSHTML.HTMLDocument) As MSHTML.HTMLTable\r\n Dim objTable As MSHTML.HTMLTable\r\n Set objTable = objDocument.createElement("Table")\r\n objDocument.Body.appendChild objTable\r\n objDocument.Body.Style.fontFamily = "calibri"\r\n objDocument.Body.Style.FontSize = "8px"\r\n With objTable\r\n .Style.borderCollapse = "collapse"\r\n End With\r\n Set TabelleErstellen = objTable\r\nEnd Function<\/pre>\n![\"pic011.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic011.png\")
<\/p>\nPrivate Function ZelleTagAnlegen(dat As Date, objRow As MSHTML.HTMLTableRow)\r\n Dim objCell As MSHTML.HTMLTableCell\r\n Dim strBGColorCurrent As String\r\n strBGColorCurrent = RGBToHTML(HexFromLong(DLookup("KalenderFarbeAktuellerTag", "tblOptionen")))\r\n Set objCell = objRow.insertCell\r\n With objCell\r\n .Style.fontFamily = "Calibri"\r\n .Style.FontSize = "12px"\r\n .innerHTML = Format(dat, "ddd.") & "<br>" & Format(dat, "dd.mm.")\r\n .Style.TextAlign = "center"\r\n .Style.padding = "0px"\r\n .Style.margin = "0px"\r\n .Style.Width = "40px"\r\n End With\r\n Select Case Weekday(dat, vbMonday)\r\n Case 6, 7\r\n objCell.Style.FontWeight = "bold"\r\n objCell.Style.backgroundColor = "#eeeeee"\r\n End Select\r\n If dat = Date Then\r\n objCell.Style.backgroundColor = strBGColorCurrent\r\n End If\r\nEnd Function<\/pre>\n![\"pic013.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic013.png\")
<\/p>\n![\"pic012.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic012.png\")
<\/p>\nPrivate Sub ZeileAbteilungEinfuegen(objTable As MSHTML.HTMLTable, strAbteilung As String)\r\n Dim objRow As MSHTML.HTMLTableRow\r\n Dim objCell As MSHTML.HTMLTableCell\r\n Set objRow = objTable.insertRow\r\n With objRow\r\n .Style.Height = "20px"\r\n End With\r\n Set objCell = objRow.insertCell\r\n With objCell\r\n .innerText = strAbteilung\r\n .Style.borderTopColor = "#000000"\r\n .Style.borderTopStyle = "solid"\r\n .Style.borderTopWidth = "1px"\r\n .Style.borderBottomColor = "#000000"\r\n .Style.borderBottomStyle = "solid"\r\n .Style.borderBottomWidth = "1px"\r\n .colSpan = 30\r\n End With\r\nEnd Sub<\/pre>\n
Private Function ZeileMitarbeiterEinfuegen( _\r\n objTable As MSHTML.HTMLTable) _\r\n As MSHTML.HTMLTableRow\r\n Dim objRow As MSHTML.HTMLTableRow\r\n Set objRow = objTable.insertRow\r\n With objRow\r\n .Style.Height = "30px"\r\n .Style.BorderWidth = "0px"\r\n .Style.margin = "0px"\r\n End With\r\n Set ZeileMitarbeiterEinfuegen = objRow\r\nEnd Function<\/pre>\n
Private Sub ZeilenkopfMitarbeiterEinfuegen(objRow As MSHTML.HTMLTableRow, strMitarbeiter As String)\r\n Dim objCell As MSHTML.HTMLTableCaption\r\n Set objCell = objRow.insertCell\r\n With objCell\r\n .innerText = strMitarbeiter\r\n .Style.fontFamily = "Calibri"\r\n .Style.FontSize = "12px"\r\n .Style.verticalAlign = "middle"\r\n End With\r\n Set objCell = objRow.insertCell\r\n objCell.Style.Width = "10px"\r\nEnd Sub<\/pre>\n
Private Function TabelleTagMitarbeiterHinzufuegen(objDocument As MSHTML.HTMLDocument, objCell As MSHTML.HTMLTableCell, objTableCell As clsTableCell)\r\n Dim objInnerTable As MSHTML.HTMLTable\r\n Set objInnerTable = objDocument.createElement("Table")\r\n objCell.appendChild objInnerTable\r\n With objInnerTable\r\n .Style.borderCollapse = "collapse"\r\n End With\r\n ZeileTagMitarbeiterHinzufuegen objInnerTable, objTableCell\r\nEnd Function<\/pre>\nPrivate Sub ZeileTagMitarbeiterHinzufuegen(objInnerTable As MSHTML.HTMLTable, _\r\n objTableCell As clsTableCell)\r\n Dim objInnerRow As MSHTML.HTMLTableRow\r\n Set objInnerRow = objInnerTable.insertRow\r\n With objInnerRow\r\n .Style.Height = "30px"\r\n End With\r\n Set objTableCell.cellLeft = InnereZelleTagMitarbeiterHinzufuegen(objInnerRow)\r\n Set objTableCell.cellRight = InnereZelleTagMitarbeiterHinzufuegen(objInnerRow)\r\nEnd Sub<\/pre>\n
Private Function InnereZelleTagMitarbeiterHinzufuegen(objInnerRow As MSHTML.HTMLTableRow)\r\n Dim objInnerCell As MSHTML.HTMLTableCell\r\n Dim strBGColorCells As String\r\n strBGColorCells = RGBToHTML(HexFromLong(DLookup("KalenderHintergrundfarbe", "tblOptionen")))\r\n Set objInnerCell = objInnerRow.insertCell\r\n With objInnerCell\r\n .Style.backgroundColor = strBGColorCells\r\n .Style.Width = "20px"\r\n End With\r\n Set InnereZelleTagMitarbeiterHinzufuegen = objInnerCell\r\nEnd Function<\/pre>\ncolTableCells.Add objTableCell, CLng(rstMitarbeiter!MitarbeiterID) & "|" & CLng(datAktuell)<\/pre>\n
Private Sub FehlzeitenEintragen(datStart As Date, datEnde As Date)\r\n Dim db As DAO.Database\r\n Dim rstFehlzeiten As DAO.Recordset\r\n Dim strFarbe As String\r\n Dim strFehlzeitart As String\r\n Set db = CurrentDb\r\n Set rstFehlzeiten = db.OpenRecordset("SELECT * FROM qryFehlzeitenUndFarben WHERE Fehlzeitdatum >= " _\r\n & ISODatum(datStart) & " AND Fehlzeitdatum < " & ISODatum(datEnde), dbOpenDynaset)\r\n Do While Not rstFehlzeiten.EOF\r\n strFarbe = HexFromLong(rstFehlzeiten!Farbe)\r\n strFehlzeitart = rstFehlzeiten!Fehlzeitart\r\n FehlzeitEintragen CLng(rstFehlzeiten!Fehlzeitdatum), rstFehlzeiten!MitarbeiterID, _\r\n rstFehlzeiten!Vormittags, strFarbe, strFehlzeitart\r\n rstFehlzeiten.MoveNext\r\n Loop\r\n Set db = Nothing\r\nEnd Sub<\/pre>\n![\"pic014.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic014.png\")
<\/p>\nPublic Sub FehlzeitEintragen(lngDatum As Long, lngMitarbeiterID As Long, intVormittags As Integer, _\r\n strFarbe As String, strFehlzeitart As String)\r\n Dim objTableCellWrapper As clsTableCell\r\n Dim objTableCell As MSHTML.HTMLTableCell\r\n Set objTableCellWrapper = colTableCells.Item(lngMitarbeiterID & "|" & lngDatum)\r\n If intVormittags = -1 Then\r\n Set objTableCell = objTableCellWrapper.cellLeft\r\n With objTableCell\r\n .Style.backgroundColor = RGBToHTML(strFarbe)\r\n .Title = strFehlzeitart\r\n End With\r\n Else\r\n Set objTableCell = objTableCellWrapper.cellRight\r\n With objTableCell\r\n .Style.backgroundColor = RGBToHTML(strFarbe)\r\n .Title = strFehlzeitart\r\n End With\r\n End If\r\nEnd Sub<\/pre>\n
Set objTableCellWrapper = colTableCells.Item(lngMitarbeiterID & "|" & lngDatum)<\/pre>\n
![\"pic015.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic015.png\")
<\/p>\nPrivate WithEvents m_Cell As MSHTML.HTMLTableCell\r\nPrivate m_CellLeft As MSHTML.HTMLTableCell\r\nPrivate m_CellRight As MSHTML.HTMLTableCell<\/pre>\n
Public Property Set cell(objCell As HTMLTableCell)\r\n Set m_Cell = objCell\r\n m_Cell.oncontextmenu = "[Event Procedure]"\r\nEnd Property<\/pre>\n
Public Property Set cellLeft(objCell As HTMLTableCell)\r\n Set m_CellLeft = objCell\r\nEnd Property\r\nPublic Property Set cellRight(objCell As HTMLTableCell)\r\n Set m_CellRight = objCell\r\nEnd Property<\/pre>\n
Public Property Get cellLeft() As HTMLTableCell\r\n Set cellLeft = m_CellLeft\r\nEnd Property\r\nPublic Property Get cellRight() As HTMLTableCell\r\n Set cellRight = m_CellRight\r\nEnd Property<\/pre>\n
Private Function m_Cell_oncontextmenu() As Boolean\r\n Dim cbr As CommandBar\r\n Dim cbc As CommandBarControl\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Dim lngMitarbeiterID As Long\r\n Set db = CurrentDb\r\n On Error Resume Next\r\n CommandBars.Item("cbrCell").Delete\r\n On Error GoTo 0\r\n lngMitarbeiterID = CLng(m_Cell.Attributes("MitarbeiterID").Value)\r\n Set cbr = CommandBars.Add("cbrCell", msoBarPopup)\r\n Set rst = db.OpenRecordset("SELECT * FROM tblFehlzeitarten ORDER BY FehlzeitartID", dbOpenDynaset)\r\n Do While Not rst.EOF\r\n Set cbc = cbr.Controls.Add(msoControlButton)\r\n With cbc\r\n .Caption = rst!Fehlzeitart & " (kompletter Tag)"\r\n .onAction = "=FehlzeitHinzufuegen(" & CLng(m_Cell.Attributes("Datum").Value) & ", " _\r\n & lngMitarbeiterID & ", " & rst!FehlzeitartID & ", 1)"\r\n End With\r\n Set cbc = cbr.Controls.Add(msoControlButton)\r\n With cbc\r\n .Caption = rst!Fehlzeitart & " (Vormittag)"\r\n .onAction = "=FehlzeitHinzufuegen(" & CLng(m_Cell.Attributes("Datum").Value) & ", " _\r\n & lngMitarbeiterID & ", " & rst!FehlzeitartID & ", -1)"\r\n End With\r\n Set cbc = cbr.Controls.Add(msoControlButton)\r\n With cbc\r\n .Caption = rst!Fehlzeitart & " (Nachmittag)"\r\n .onAction = "=FehlzeitHinzufuegen(" & CLng(m_Cell.Attributes("Datum").Value) & ", " _\r\n & lngMitarbeiterID & ", " & rst!FehlzeitartID & ", 0)"\r\n End With\r\n rst.MoveNext\r\n Loop\r\n Set cbc = cbr.Controls.Add(msoControlButton)\r\n With cbc\r\n .Caption = "Fehlzeiten entfernen"\r\n .onAction = "=FehlzeitenEntfernen(" & CLng(m_Cell.Attributes("Datum").Value) & ", " _\r\n & lngMitarbeiterID & ")"\r\n End With\r\n cbr.ShowPopup\r\nEnd Function<\/pre>\n=FehlzeitHinzufuegen(41087, 12, 3, 1)<\/pre>\n
Public Function FehlzeitHinzufuegen(lngDatum As Long, lngMitarbeiterID As Long, _\r\n lngFehlzeitartID As Long, intTageszeit As Integer)\r\n Dim db As DAO.Database\r\n Dim strSQL As String\r\n Dim strFarbe As String\r\n Dim strFehlzeitart As String\r\n Dim i As Integer\r\n strFarbe = HexFromLong(DLookup("Farbe", "tblFehlzeitarten", "FehlzeitartID = " & lngFehlzeitartID))\r\n strFehlzeitart = DLookup("Fehlzeitart", "tblFehlzeitarten", "FehlzeitartID = " & lngFehlzeitartID)\r\n Set db = CurrentDb\r\n Select Case intTageszeit\r\n Case 1\r\n strSQL = "DELETE FROM tblFehlzeiten WHERE MitarbeiterID = " & lngMitarbeiterID _\r\n & " AND Fehlzeitdatum = " & lngDatum\r\n db.Execute strSQL, dbFailOnError\r\n For i = -1 To 0\r\n strSQL = "INSERT INTO tblFehlzeiten(MitarbeiterID, Fehlzeitdatum, " _\r\n & "FehlzeitartID, Vormittags) VALUES(" & lngMitarbeiterID & ", " & lngDatum _\r\n & ", " & lngFehlzeitartID & ", " & i & ")"\r\n db.Execute strSQL, dbFailOnError\r\n FehlzeitEintragen CLng(lngDatum), lngMitarbeiterID, i, strFarbe, strFehlzeitart\r\n Next i\r\n Case Else\r\n strSQL = "DELETE FROM tblFehlzeiten WHERE MitarbeiterID = " & lngMitarbeiterID _\r\n & " AND Fehlzeitdatum = " & lngDatum & " AND Vormittags = " & intTageszeit\r\n db.Execute strSQL, dbFailOnError\r\n strSQL = "INSERT INTO tblFehlzeiten(MitarbeiterID, Fehlzeitdatum, " _\r\n & "FehlzeitartID, Vormittags) VALUES(" & lngMitarbeiterID & ", " & lngDatum _\r\n & ", " & lngFehlzeitartID & ", " & intTageszeit & ")"\r\n db.Execute strSQL, dbFailOnError\r\n FehlzeitEintragen CLng(lngDatum), lngMitarbeiterID, intVormittags, strFarbe, strFehlzeitart\r\n End Select\r\n Set db = Nothing\r\nEnd Function<\/pre>\n
![\"pic016.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic016.png\")
<\/p>\n![\"pic017.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic017.png\")
<\/p>\n![\"pic018.png\"](\"..\/fileadmin\/_temp_\/2012_04\/FehlzeitenVerwalten-web-images\/pic018.png\")
<\/p>\n