<\/p>\n
Im Beitrag „Benutzerverwaltung mit verschlüsselten Kennwörtern“ stellen wir eine Lösung vor, in der wir die Berechtigungen von Benutzergruppen an Datenbankobjekten definieren. Dort benötigen wir ein Formular, mit dem wir die Berechtigungen für die einzelnen Objekte für die jeweilige Benutzergruppe definieren wollen. Dazu wollen wir eine Matrix anzeigen, welche die Berechtigungen und die Objekte als Spalten- und Zeilenüberschriften anzeigt und die Möglichkeit bietet, in den Zellen anzugeben, ob die Berechtigung gesetzt ist oder nicht. Dies erledigen wir mit einem Webbrowser-Steuerelement, indem wir die notwendigen Elemente per HTML darstellen.<\/b><\/p>\n
Der erste Entwurf des Formulars sieht wie in Bild 1 aus. Wir haben dem Formular ein Kombinationsfeld namens cboBenutzergruppeID <\/b>hinzugefügt sowie ein Webbrowser-Steuerelement namens objWebbrowser<\/b>.<\/p>\n
![\"Erster](\"..\/fileadmin\/_temp_\/2019_03\/pic_1191_001.png\")
<\/p>\n
Bild 1: Erster Entwurf des Formulars<\/span><\/b><\/p>\n Das Kombinationsfeld soll die Benutzergruppen aus der Tabelle tblBenutzergruppen <\/b>anzeigen, und zwar so, dass das Feld BenutzergruppeID <\/b>als gebundene Spalte ausgeblendet wird und nur die Bezeichnung der Benutzergruppe erscheint. Dazu weisen wir der Eigenschaft Datensatzherkunft <\/b>die folgende Abfrage zu:<\/p>\n Damit nur die Benutzergruppe angezeigt wird, stellen wir die Eigenschaft Spaltenanzahl <\/b>auf 2 <\/b>und die Eigenschaft Spaltenbreiten <\/b>auf 0cm <\/b>ein.<\/p>\n Für das Zusammenstellen des HTML-Code benötigen wir noch die Objektbibliothek Microsoft HTML Object Library<\/b>, die wir wie in Bild 2 über den Verweise<\/b>-Dialog des VBA-Editors hinzufügen (Menüeintrag Extras|Verweise<\/b>).<\/p>\n Bild 2: Verweise des VBA-Projekts<\/span><\/b><\/p>\n Wir möchten nicht einfach nur eine Darstellung mit Kontrollkästchen oder ähnlichen Steuer-elementen, sondern einmal etwas Besonderes programmieren: nämlich eine Darstellung, bei der die gesetzten Rechte in Grün und die nicht gesetzten Rechte in Rot dargestellt werden. Das sieht dann etwa für die Benutzergruppe Administratoren <\/b>wie in Bild 3 aus.<\/p>\n Bild 3: Setzen der Berechtigungen über verschiedene Farben<\/span><\/b><\/p>\n Das Formular soll, wie oben erwähnt, die Auswahl einer der Benutzergruppen über das Kombinationsfeld oben im Formular ermöglichen. Nach der Auswahl sollen die Berechtigungen für die gewählte Benutzergruppe angezeigt werden.<\/p>\n Außerdem wollen wir die folgenden Funktionen durch Anklicken der verschiedenen Bereiche der HTML-Seite im Webbrowser-Steuerelement realisieren:<\/p>\n Wenn Keine <\/b>grün ist, müssen also alle anderen Spalten für diese Tabelle rot sein, wenn eine der anderen Spalten grün ist, muss Keine <\/b>rot sein.<\/p>\n Im Klassenmodul des Formulars deklarieren wir die folgenden Variablen im allgemeinen Teil, das heißt, die Variablen sind modulweit zugreifbar:<\/p>\n Die ersten beiden Variablen referenzieren später das Webbrowser-Steuerelement sowie das darin angezeigte Dokument. Die übrigen beiden, colCells<\/b> und colCellWrapper<\/b>, sind Collection<\/b>-Objekte, welche Objekte aufnehmen, die wir auf Basis zweier weiter unten beschrieben Klassen erstellen €“ und zwar für jedes Element der Tabelle aus der Kopfzeile und den farbig zu markierenden Tabellenzellen.<\/p>\n Beim Ã-ffnen des Formulars weisen wir der Variablen obj-Webbrowser <\/b>das Steuer-element ctlWebbrowser.Object <\/b>zu. Außerdem stellen wir die Eigenschaft TimerInterval <\/b>auf 50 <\/b>ein, was dazu führt, dass die Ereignisprozedur Bei Zeitgeber <\/b>50 Millisekunden nach dem Einstellen dieser Eigenschaft aufgerufen wird:<\/p>\n Die durch das Ereignis Bei Zeitgeber <\/b>ausgelöste Prozedur zeigt zunächst eine leere Seite im Webbrowser<\/b>-Steuerelement an und stellt die Variable objDocument <\/b>auf die Eigenschaft Document <\/b>des Webbrowser<\/b>-Steuerelements ein. Dann stellt sie TimerInterval <\/b>auf 0<\/b>, damit das Ereignis Bei Zeitgeber <\/b>nicht nochmals ausgelöst wird. Schließlich stellt sie das Kombinationsfeld cboBenutzergruppeID <\/b>auf den ersten Eintrag der Datensatzherkunft ein und ruft die Prozedur TabelleErstellen <\/b>auf. Dieser übergibt sie die aktuell im Kombinationsfeld ausgewählte Benutzergruppe als Parameter, damit die Prozedur die dazu gehörenden Berechtigungen im Webbrowser<\/b>-Steuerelement anzeigt:<\/p>\n Die Prozedur TabelleErstellen <\/b>wird außerdem aufgerufen, wenn der Benutzer im Kombinationsfeld cboBenutzergruppe <\/b>einen anderen Eintrag auswählt. Dazu legen wir die folgende Prozedur an, die durch das Ereignis Nach Aktualisierung <\/b>des Kombinationsfeldes aufgerufen wird:<\/p>\n In der nachfolgend mit der Prozedur TabelleErstellen <\/b>zusammengestellten HTML-Tabelle verwenden wir auch einige Zeilen CSS-Code. Diese stellen wir mit der folgenden Funktion zusammen. Die ersten CSS-Anweisungen legen die Schriftart, Schriftgröße, Ausrichtung und Rahmeneigenschaften für die Tabellen fest:<\/p>\n Dann folgen zwei Definitionen für CSS-Klassen, welche die Hintergrundfarben für die roten und grünen Zellen festlegen:<\/p>\n Dann benötigen wir noch zwei Klassen für die Breite der ersten Spalte (50%) und die der folgenden fünf Spalten (jeweils 10%):<\/p>\n Schließlich fehlt noch eine CSS-Klasse namens scrolling<\/b>, welche die Höhe des zu scrollenden Bereiches festlegt und dass dieser gescrollt werden kann:<\/p>\n Nach dieser Vorbereitung kommen wir zur Prozedur TabelleErstellen<\/b>, deren ersten Teil Sie in Listing 1 finden. Diese Prozedur deklarieren wir als öffentliche Prozedur, damit wir später von Klassenobjekten, die wir von dieser Prozedur aus erstellt haben, erneut auf diese Prozedur zugreifen können, um die Tabelle neu zu erstellen.<\/p>\n Listing 1: Prozedur TabelleErstellen, Teil 1<\/span><\/b><\/p>\n Die Prozedur erwartet die ID der Benutzergruppe, deren Berechtigungen an den verschiedenen Tabellen der Datenbank in der HTML-Tabelle dargestellt werden sollen. Sie deklariert eine ganze Reihe von Variablen. Die drei Variablen rstSpaltenkoepfe<\/b>, rstZeilen <\/b>und rstWerte <\/b>nehmen die Recordsets auf, deren Daten wir in der HTML-Tabelle abbilden wollen. Wie wir diese genau füllen, erfahren Sie weiter unten.<\/p>\n Dazu benötigen wir einige Objekte, mit denen wir die Objekte der HTML-Seite definieren und hierarchisch anordnen. Wir wollen in diesem Beispiel nicht wie etwa in dem Beispiel zum Beitrag HTML-Tabellen mit fester Kopfzeile <\/b>(www.access-im-unternehmen.de\/1188<\/b>) den HTML-Code in einer String<\/b>-Variablen zusammensetzen, sondern diesmal das Objektmodell für HTML verwenden (DOM, Document Object Model).<\/p>\n Die ersten Anweisungen der Prozedur erzeugen jeweils neue Collection<\/b>-Objekte für die beiden Variablen colCells <\/b>und colCellWrapper<\/b>, die wie im Kopf des Klassenmoduls deklariert haben. Dann erstellen wir die Klasse, welche den Code der Funktion CSS <\/b>als Wert der Eigenschaft cssText <\/b>aufnimmt. Außerdem benötigen wir ein Database-Objekt für den Zugriff auf die Objekte der aktuellen Datenbank.<\/p>\n Für das mit der Variablen objDocument <\/b>referenzierten Objektvariablen für das Dokument im Webbrowser<\/b>-Steuerelement stellen wir die Eigenschaft body.innerHTML <\/b>auf eine leere Zeichenkette ein. Dann erstellen wir für objDocument <\/b>mit der createElement<\/b>-Methode ein neues Element des Typs Table<\/b> und hängen es mit der appendChild<\/b>-methode an das body<\/b>-Objekt von objDocument <\/b>an. Als Nächstes fügen wir unterhalb des Table<\/b>-Objekts aus objTable <\/b>mit der insertRow<\/b>-Methode ein neues Row<\/b>-Element ein und referenzieren es mit objRow<\/b>. Darin fügen wir nun ein erstes Cell<\/b>-Objekt ein, welches der linken, oberen Zelle entspricht, die keinen Text aufnehmen soll. Dazu verwenden wir die insertCell<\/b>-Methode von objRow <\/b>und speichern das Ergebnis in objCell<\/b>. objCell<\/b> ist das erste Objekt, dem wir CSS-Klassen zuweisen. Das erledigen wir über die Eigenschaft className<\/b>, der wir den Text columnHeader rowHeader th1 <\/b>zuweisen. Dadurch nimmt das Element die in den drei CSS-Klassen td.columnHeader<\/b>, td.rowHeader <\/b>und th1 <\/b>angegebenen Attribute an.<\/p>\n Danach füllen wir die erste Recordset<\/b>-Variable namens rstSpaltenkoepfe<\/b>, und zwar mit den Feldern BerechtigungID <\/b>und Berechtigung <\/b>der Datensätze der Tabelle tblBerechtigungen<\/b>. Diese durchlaufen wir anschließend in einer Do While<\/b>-Schleife über alle Einträge des Recordsets. In der Do While<\/b>-Schleife erstellen wir jeweils ein neues Cell<\/b>-Objekt und referenzieren diese wieder mit objCell<\/b>. Wir weisen über die Eigenschaft className <\/b>die beiden CSS-Klassen columnHeader <\/b>und th2 <\/b>zu. Außerdem wollen wir den in den Zellen anzuzeigenden Text definieren. Diesen entnehmen wir dem Feld Berechtigung <\/b>des aktuellen Datensatzes des Recordsets rstSpaltenkoepfe<\/b>.<\/p>\n Für diese Spaltenköpfe, jeweils einer für jeden Berechtigungstyp, wollen wir nun jeweils eine Ereignisprozedur definieren, die beim Anklicken des Spaltenkopfes ausgelöst wird. Das können wir nicht so einfach wie bei einer Schaltfläche in einem Access-Formular erledigen, denn es handelt sich ja bei den Tabellenzellen nicht um Steuerelemente, die wir dem Formularentwurf hinzufügen und deren Ereigniseigenschaften wir dann definieren und mit Ereignisprozeduren hinterlegen können. Es ist etwas komplizierter. Wir benötigen für jedes mit Ereignissen zu versehende Element eine eigene Instanz einer Klasse, die dann wiederum auf das darin deklarierte Element verweist und die gewünschten Ereignisse des Elements implementiert.<\/p>\n Wir schauen uns die Sache erst einmal der Seite unserer Prozedur an, mit der wir die HTML-Tabelle erstellen. Dort legen wir für jedes Cell<\/b>-Element für eine Berechtigung ein neues Objekt auf Basis der Klasse clsCellHeaderWrapper <\/b>an und speichern es in der Variablen objCellHeaderWrapper<\/b>. Diesem weisen wir dann über die Eigenschaft cell <\/b>die Objektvariable objCell <\/b>zu. Die Eigenschaft BerechtigungID <\/b>erhält den Wert des Feldes BerechtigungID <\/b>des aktuellen Datensatzes des Recordsets rstSpaltenkoepfe<\/b>. Die Eigenschaft BenutzergruppeID <\/b>erhält den Wert des Kombinationsfeldes cboBenutzergruppeID<\/b> des Formulars. Außerdem stellen wir über die Eigenschaft Form <\/b>noch einen Verweis auf das Formular ein (Me<\/b>).<\/p>\n Da wir objCellHeaderWrapper <\/b>schon im nächsten Schleifendurchlauf mit den Eigenschaften des nächsten Cell<\/b>-Objekts füllen, speichern wir die aktuelle Instanz noch schnell mit der Add<\/b>-Methode in der Collection colCellWrapper<\/b>. Danach bewegen wir den Datensatzzeiger zu nächsten Datensatz und beginnen die Schleife von vorn, bis alle fünf Berechtigungen durchlaufen sind. Damit steht schon einmal die erste Zeile der Tabelle.<\/p>\n Den zweiten Teil der Prozedur TabelleErstellen <\/b>finden Sie in Listing 2. Hier füllen wir das Recordset rstZeilen <\/b>mit allen Datensätzen der Tabelle tblTabellen<\/b>. Bevor wir diese durchlaufen, legen wir noch einige weitere Elemente an. Dem Objekt objTable <\/b>fügen wir mit insertRow <\/b>eine neue Zeile hinzu, die wir in objRow <\/b>speichern. Dieser fügen wir diesmal nur eine einzige Zelle hinzu, die sich aber durch den Wert 6 <\/b>für die Eigenschaft colSpan <\/b>über die kompletten sechs Spalten der ersten Zeile der Tabelle erstreckt.<\/p>\n <\/p>\n Listing 2: Prozedur TabelleErstellen, Teil 2<\/span><\/b><\/p>\n Wir erstellen in objDiv <\/b>ein neues Div<\/b>-Objekt für objDocument <\/b>und fügen es mit der appendChild<\/b>-Methode in das Objekt objCell <\/b>ein. Diesem Div<\/b>-Element weisen wir die Klasse scrolling <\/b>zu. Das Div<\/b>-Element umfasst also den scrollbaren Bereich der Tabelle €“ wir wollen ja, dass nur der untere Teil der Tabelle gescrollt wird und die Spaltenköpfe am oberen Rand der HTML-Tabelle fixiert werden.<\/p>\n Danach erstellen wir ein weiteres Table<\/b>-Element, das wir dem Div<\/b>-Element unterordnen. Dieses Table<\/b>-Element füllen wir dann in einer Do While<\/b>-Schleife über alle Datensätze des Recordsets rstZeilen <\/b>mit der entsprechenden Anzahl Zeilen beziehungsweise Row<\/b>-Elementen.<\/p>\n In der Do While<\/b>-Schleife kommen wir nun auf das Recordset rstSpaltenkoepfe <\/b>zurück, dessen Datensatzzeiger wir mit der MoveFirst<\/b>-Methode wieder an die erste Position verschieben. Bevor wir dieses Recordset nutzen, folgen noch einige neue Elemente: Zunächst ein erstes Cell<\/b>-Element, das wir dem aktuellen objRow<\/b>-Element, also der neuen Zeile der HTML-Tabelle, unterordnen. Diesem ersten Element weisen wir als Text den Namen der Tabelle aus dem Feld Tabelle <\/b>des Recordsets rstZeilen <\/b>zu. Außerdem stellen wir die CSS-Klassen rowHeader <\/b>und th1 <\/b>für die Eigenschaft className <\/b>ein.<\/p>\n Damit haben wir die erste Zelle der aktuellen Zeile der HTML-Tabelle mit dem Namen der Tabelle gefüllt, deren Berechtigungen nun in Form von roten oder grünen Kästchen folgen. Dazu füllen wir das Recordset rstWerte <\/b>mit den Daten der Tabelle tblBerechtigungszuordnungen<\/b>, deren Benutzergruppe der im Kombinationsfeld ausgewählten Benutzergruppe und deren Tabelle der Tabelle für die aktuelle Zeile entspricht.<\/p>\n Die Datensätze des Recordsets rstSpaltenkoepfe <\/b>durchlaufen wir nun in einer untergeordneten Do While<\/b>-Schleife. Nun suchen wir im Recordset rstWerte <\/b>nach dem Datensatz, dessen Feld BerechtigungID <\/b>dem Wert des Feldes BerechtigungID <\/b>des aktuellen Datensatzes des Recordsets Spaltenkoepfe <\/b>entspricht.<\/p>\n Ist ein solcher Datensatz vorhanden, wurde diese Berechtigung für die Kombination aus Benutzergruppe und Tabelle in der Tabelle tblBerechtigungszuordnungen <\/b>zugeordnet. Dies prüft die folgende If…Then<\/b>-Bedingung, welche den Wert von rstWerte.NoMatch <\/b>untersucht.<\/p>\n Ist die Berechtigung für die Kombination aus Tabelle und Benutzergruppe gesetzt, fügen wir der Collection colCells <\/b>ein neues Objekt hinzu, das wir mit der Funktion ZelleHinzufuegen <\/b>ermitteln. Dieser übergeben wir als Parameter das Row<\/b>-Objekt aus objRow<\/b>, den Namen der zuzuweisenden Klasse (im Falle einer Berechtigungszuweisung greencell<\/b>), die Werte der Tabellen tblBerechtigungszuordnungen<\/b>, tblBerechtigungen <\/b>und tblTabellen <\/b>aus den jeweiligen Recordsets sowie die ID der Benutzergruppe.<\/p>\n Wenn kein solcher Datensatz vorhanden ist, wird ebenfalls die Funktion ZelleHinzufuegen <\/b>aufgerufen. Diesmal wird allerdings der Wert 0 <\/b>für den Parameter mit der Berechtigungszuordnung übergeben sowie der Klassenname redcell<\/b>.<\/p>\n Auf diese Weise durchläuft die Prozedur alle Spalten für die aktuelle Tabelle und dann die Spalten in den Zeilen für die übrigen Tabellen. Die letzte Anweisung fügt zu Kontrollzwecken den so erstellen HTML-Code in die Zwischenablage ein €“ Sie können diesen dann etwa in einen Texteditor kopieren, um den Code zu kontrollieren.<\/p>\n Die Anweisungen der Funktion ZelleHinzufuegen <\/b>haben wir in eine eigene Funktion ausgegliedert, weil wir in der zuletzt beschriebenen If…Then<\/b>-Bedingung in der Prozedur TabelleErstellen <\/b>sonst annähernd den gleichen Quellcode zwei Mal abgebildet hätten.<\/p>\n Die Funktion sieht wie in Listing 3 aus. Sie erwartet die weiter oben bereits beschriebenen Parameter. Sie erstellt ein neues Cell<\/b>-Objekt und ordnet dies dem mit dem Parameter objRow <\/b>übergebenen Row<\/b>-Objekt unter. Dann stellt sie die Eigenschaft ID <\/b>dieses Objekts auf den Wert des Parameters lngBerechtigungszuordnung <\/b>fest. Außerdem stellt Sie die Eigenschaft className <\/b>auf den entsprechenden Parameter ein, also entweder greencell <\/b>oder redcell<\/b>.<\/p>\n Listing 3: Die Funktion ZelleHinzufuegen<\/span><\/b><\/p>\n Dann legen wir auch für dieses Zellen jeweils ein neues Objekt auf Basis einer Wrapperklasse an, diesmal des Typs clsCellWrapper<\/b>. Auch dieses Klasse betrachten wir weiter unten. Der neuen Instanz dieser Klasse weisen wir für die Eigenschaften BerechtigungszuordnungID<\/b>, BerechtigungID<\/b>, TabelleID <\/b>und BenutzergruppeID <\/b>die Werte der entsprechenden Parameter zu sowie einen Verweis auf das Cell<\/b>-Objekt, welches diese Kombination der Parameter repräsentiert.<\/p>\n Dieses neue Objekt ist gleichzeitig das Ergebnis der Funktion, das wir dann in der aufrufenden Prozedur TabelleErstellen <\/b>zur Collection colCells <\/b>hinzufügen.<\/p>\n Die Klasse clsCellHeaderWrapper <\/b>soll die Ereignisse für die Zellen mit den Spaltenköpfen der HTML-Tabelle implementieren. Das heißt, dass wir für jedes der fünf (es können auch mehr sein, wenn Sie noch weitere Berechtigungsstufen anlegen) HTMLTableCell<\/b>-Elemente eine Instanz der Klasse clsCellHeaderWrapper <\/b>anlegen und dieser einen Verweis auf das HTMLTableCell<\/b>-Element zuweisen. Außerdem weisen wir dieser Klasse noch ein paar weitere Eigenschaften zu. Diese deklarieren wir wie folgt im Kopf des über den Befehl Einfügen|Klassenmodul <\/b>im VBA-Editor neu einzufügenden Klassenmoduls:<\/p>\n Die Variable für das HTMLTableCell<\/b>-Objekte deklarieren wir mit dem Schlüsselwort WithEvents<\/b>. Dadurch erhalten wir die Möglichkeit, die Ereignisse für diese Objektvariable in diesem Klassenmodul zu implementieren. Damit wir diese Variable etwa von der Funktion TabelleErstellen <\/b>aus mit dem gewünschten HTMLTableCell<\/b>-Objekt füllen können, legen wir die folgende Property Set<\/b>-Methode an:<\/p>\n Wenn der Benutzer auf einen der Spaltenköpfe klickt, um die Berechtigungen für alle Tabellen zu aktivieren, sind umfangreichere Änderungen an der HTML-Tabelle nötig. So viele, dass wir diese nicht einzeln durchführen wollen, sondern lieber direkt die vollständige Tabelle neu erstellen. Also wollen wir in diesem Fall die Methode TabelleErstellen <\/b>des Formulars erneut aufrufen. Damit wir dies können, übergeben wir vom Formular aus über die Prozedur TabelleErstellen <\/b>einen Verweis auf das Formular selbst. Über dieses können wir dann die Methode TabellenErstellen <\/b>aufrufen, wie wir später sehen werden. Die Objektvariable m_Form <\/b>haben wir weiter oben bereits deklariert. Mit der folgenden Property Set<\/b>-Prozedur nimmt die Klasse den Verweis auf das Form<\/b>-Objekt entgegen:<\/p>\n Schließlich wollen wir noch die BerechtigungID <\/b>zu dem HTMLTableCell<\/b>-Objekte übergeben sowie die Benutzergruppe-ID <\/b>des aktuell mit dem Kombinationsfeld ausgewählten Benutzergruppe. Diese Informationen nimmt die Klasse mit den folgenden beiden Property Let<\/b>-Prozeduren entgegen:<\/p>\nSELECT BenutzergruppeID, Benutzergruppe \r\nFROM tblBenutzergruppen \r\nORDER BYBenutzergruppe;<\/pre>\n
![\"Verweise](\"..\/fileadmin\/_temp_\/2019_03\/pic_1191_002.png\")
<\/p>\nGewünschte Darstellung<\/h2>\n
![\"Setzen](\"..\/fileadmin\/_temp_\/2019_03\/pic_1191_003.png\")
<\/p>\nFunktionen des Formulars<\/h2>\n
\n
Initialisieren des Formulars<\/h2>\n
Dim <\/span>WithEvents objWebbrowser As <\/span>WebBrowser\r\nDim <\/span>WithEvents objDocument As <\/span>HTMLDocument\r\nPublic <\/span>colCells As <\/span>Collection\r\nPublic <\/span>colCellWrapper As <\/span>Collection<\/pre>\nPrivate Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Set<\/span> objWebbrowser = Me!ctlWebbrowser.Object\r\n Me.TimerInterval = 50\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Timer()\r\n objWebbrowser.Navigate \"about:blank\"\r\n Set<\/span> objDocument = objWebbrowser.Document\r\n Me.TimerInterval = 0\r\n DoEvents\r\n Me!cboBenutzergruppeID = Me!cboBenutzergruppeID.ItemData(0)\r\n TabelleErstellen Me!cboBenutzergruppeID\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cboBenutzergruppeID_AfterUpdate()\r\n TabelleErstellen Me!cboBenutzergruppeID\r\nEnd Sub<\/span><\/pre>\nCSS-Definition<\/h2>\n
Public Function <\/span>CSS()\r\n Dim <\/span>strCSS As String<\/span>\r\n strCSS = strCSS & \"table {\"\r\n strCSS = strCSS & \" font-family: Calibri;\"\r\n strCSS = strCSS & \" text-align: center;\"\r\n strCSS = strCSS & \" width: 100%;\"\r\n strCSS = strCSS & \" border-collapse: collapse;\"\r\n strCSS = strCSS & \"}\"\r\n strCSS = strCSS & \"td.columnHeader {\"\r\n strCSS = strCSS & \" font-weight: bold;\"\r\n strCSS = strCSS & \" border-bottom: 1px solid black;\"\r\n strCSS = strCSS & \"}\"\r\n strCSS = strCSS & \"td.rowHeader {\"\r\n strCSS = strCSS & \" font-weight: bold;\"\r\n strCSS = strCSS & \" border-right: 1px solid black;\"\r\n strCSS = strCSS & \" text-align: left;\"\r\n strCSS = strCSS & \"}\"<\/pre>\n strCSS = strCSS & \"td.redcell{\"\r\n strCSS = strCSS & \" border-color: white;\"\r\n strCSS = strCSS & \" border-width: 1px;\"\r\n strCSS = strCSS & \" border-style: solid;\"\r\n strCSS = strCSS & \" background: red;\"\r\n strCSS = strCSS & \"}\"\r\n strCSS = strCSS & \"td.greencell{\"\r\n strCSS = strCSS & \" border-color: white;\"\r\n strCSS = strCSS & \" border-width: 1px;\"\r\n strCSS = strCSS & \" border-style: solid;\"\r\n strCSS = strCSS & \" background: green;\"\r\n strCSS = strCSS & \"}\"<\/pre>\n strCSS = strCSS & \".th1 {\"\r\n strCSS = strCSS & \" width:50%;\"\r\n strCSS = strCSS & \" text-align:left;\"\r\n strCSS = strCSS & \"}\"\r\n strCSS = strCSS & \".th2 {\"\r\n strCSS = strCSS & \" width:10%;\"\r\n strCSS = strCSS & \" text-align:left;\"\r\n strCSS = strCSS & \"}\"<\/pre>\n strCSS = strCSS & \".scrolling {\"\r\n strCSS = strCSS & \" height:300px;\"\r\n strCSS = strCSS & \" overflow:auto;\"\r\n strCSS = strCSS & \"}\"\r\n CSS = strCSS\r\nEnd Function<\/span><\/pre>\nTabelle zusammenstellen<\/h2>\n
Public Sub <\/span>TabelleErstellen(lngBenutzergruppeID As Long<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstSpaltenkoepfe As <\/span>DAO.Recordset\r\n Dim <\/span>rstZeilen As <\/span>DAO.Recordset\r\n Dim <\/span>rstWerte As <\/span>DAO.Recordset\r\n Dim <\/span>objTable As <\/span>MSHTML.HTMLTable\r\n Dim <\/span>objRow As <\/span>MSHTML.HTMLTableRow\r\n Dim <\/span>objCell As <\/span>MSHTML.HTMLTableCell\r\n Dim <\/span>objCSS As Object<\/span>\r\n Dim <\/span>objCellHeaderWrapper As <\/span>clsCellHeaderWrapper\r\n Dim <\/span>objInnerTable As <\/span>MSHTML.HTMLTable\r\n Dim <\/span>objDiv As <\/span>MSHTML.HTMLDivElement\r\n Set<\/span> colCells = New<\/span> Collection\r\n Set<\/span> colCellWrapper = New<\/span> Collection\r\n Set<\/span> objCSS = objDocument.createStyleSheet(\"\")\r\n objCSS.cssText = CSS\r\n Set<\/span> db = CurrentDb\r\n objDocument.body.innerHTML = \"\"\r\n Set<\/span> objTable = objDocument.createElement(\"Table\")\r\n objDocument.body.appendChild objTable\r\n Set<\/span> objRow = objTable.insertRow\r\n Set<\/span> objCell = objRow.insertCell\r\n objCell.className = \"columnHeader rowHeader th1\"\r\n Set<\/span> rstSpaltenkoepfe = db.OpenRecordset(\"SELECT BerechtigungID, Berechtigung FROM tblBerechtigungen\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstSpaltenkoepfe.EOF\r\n Set<\/span> objCell = objRow.insertCell\r\n objCell.className = \"columnHeader th2\"\r\n objCell.innerText = rstSpaltenkoepfe!Berechtigung\r\n Set<\/span> objCellHeaderWrapper = New<\/span> clsCellHeaderWrapper\r\n With<\/span> objCellHeaderWrapper\r\n Set<\/span> .cell = objCell\r\n .BerechtigungID = rstSpaltenkoepfe!BerechtigungID\r\n .BenutzergruppeID = Me!cboBenutzergruppeID\r\n Set<\/span> .Form = Me\r\n End With<\/span>\r\n colCellWrapper.Add objCellHeaderWrapper\r\n rstSpaltenkoepfe.MoveNext<\/span>\r\n Loop<\/span><\/pre>\nEreignisse für Spaltenköpfe<\/h2>\n
Tabellenkörper hinzufügen<\/h2>\n
Set<\/span> rstZeilen = db.OpenRecordset(\"SELECT * FROM tblTabellen\", dbOpenDynaset)\r\n Set<\/span> objRow = objTable.insertRow\r\n Set<\/span> objCell = objRow.insertCell\r\n objCell.colSpan = 6\r\n Set<\/span> objDiv = objDocument.createElement(\"Div\")\r\n objCell.appendChild objDiv\r\n objDiv.className = \"scrolling\"\r\n Set<\/span> objInnerTable = objDocument.createElement(\"Table\")\r\n objDiv.appendChild objInnerTable\r\n Do While<\/span> Not<\/span> rstZeilen.EOF\r\n Set<\/span> objRow = objInnerTable.insertRow\r\n rstSpaltenkoepfe.MoveFirst\r\n Set<\/span> objCell = objRow.insertCell\r\n objCell.innerText = rstZeilen!Tabelle\r\n objCell.className = \"rowHeader th1\"\r\n Set<\/span> rstWerte = db.OpenRecordset(\"SELECT BerechtigungszuordnungID, BenutzergruppeID, TabelleID, \" _\r\n \"BerechtigungID FROM tblBerechtigungszuordnungen WHERE BenutzergruppeID = \" & lngBenutzergruppeID _\r\n & \" AND TabelleID = \" & rstZeilen!TabelleID, dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstSpaltenkoepfe.EOF\r\n rstWerte.FindFirst \"BerechtigungID = \" & rstSpaltenkoepfe!BerechtigungID\r\n If <\/span>Not<\/span> rstWerte.NoMatch Then<\/span>\r\n colCells.Add ZelleHinzufuegen(objRow, \"greencell\", rstWerte!BerechtigungszuordnungID, _\r\n rstSpaltenkoepfe!BerechtigungID, rstZeilen!TabelleID, lngBenutzergruppeID)\r\n Else<\/span>\r\n colCells.Add ZelleHinzufuegen(objRow, \"redcell\", 0, rstSpaltenkoepfe!BerechtigungID, _\r\n rstZeilen!TabelleID, lngBenutzergruppeID)\r\n End If<\/span>\r\n rstSpaltenkoepfe.MoveNext<\/span>\r\n Loop<\/span>\r\n rstZeilen.MoveNext<\/span>\r\n Loop<\/span>\r\n Inzwischenablage Replace<\/span>(Replace<\/span>(objDocument.documentElement.innerHTML, \"><\/\", \">\" & vbCrLf<\/span> & \"<\/\"), \"><\", \">\" _\r\n & vbCrLf<\/span> & \"<\")\r\nEnd Sub<\/span><\/pre>\nHinzufügen einer Zelle mit der Funktion ZelleHinzufuegen<\/h2>\n
Private Function <\/span>ZelleHinzufuegen(objRow As <\/span>MSHTML.HTMLTableRow, strClassname As String<\/span>, lngBerechtigungszuordnungID _\r\n As Long<\/span>, lngBerechtigungID As Long<\/span>, lngTabelleID As Long<\/span>, lngBenutzergruppeID As Long<\/span>) As <\/span>clsCellWrapper\r\n Dim <\/span>objCell As <\/span>MSHTML.HTMLTableCell\r\n Dim <\/span>objCellWrapper As <\/span>clsCellWrapper\r\n Set<\/span> objCell = objRow.insertCell\r\n objCell.ID = lngBerechtigungszuordnungID\r\n objCell.className = strClassname\r\n Set<\/span> objCellWrapper = New<\/span> clsCellWrapper\r\n With<\/span> objCellWrapper\r\n .BerechtigungzuordnungID = lngBerechtigungszuordnungID\r\n .BerechtigungID = lngBerechtigungID\r\n .TabelleID = lngTabelleID\r\n .BenutzergruppeID = lngBenutzergruppeID\r\n Set<\/span> .cell = objCell\r\n End With<\/span>\r\n Set<\/span> ZelleHinzufuegen = objCellWrapper\r\nEnd Function<\/span><\/pre>\nDie Wrapper-Klasse für die Spaltenüberschriften<\/h2>\n
Private <\/span>WithEvents m_Cell As <\/span>MSHTML.HTMLTableCell\r\nPrivate <\/span>m_BerechtigungID As Long<\/span>\r\nPrivate <\/span>m_BenutzergruppeID As Long<\/span>\r\nPrivate <\/span>m_Form As <\/span>Form<\/pre>\nPublic Property Set<\/span> <\/span>cell(cell As <\/span>MSHTML.HTMLTableCell)\r\n Set<\/span> m_Cell = cell\r\nEnd Property<\/span><\/pre>\nPublic Property Set<\/span> <\/span>Form(frm As <\/span>Form)\r\n Set<\/span> m_Form = frm\r\nEnd Property<\/span><\/pre>\n