<\/p>\n
Kreuztabellenabfragen sind eine praktische Sache, wenn es darum geht, Kombinationen aus m:n-Beziehungen abzubilden – zum Beispiel die Preise für verschiedene Bauelemente oder Materialien in Abhängigkeit von der Höhe und der Breite des Materials. Dabei benötigen Sie noch nicht einmal eine m:n-Beziehung, die in einer Kreuztabelle darzustellenden Daten können auch aus einer einzigen Tabelle stammen. Der Haken an Kreuztabellen ist, dass diese in der Regel nicht bearbeitet werden können. Wenn Sie also etwa den Preis für ein Bauelement mit einer Höhe von einem Meter und einer Breite von 50 Zentimetern einstellen wollen, müssen Sie wieder die zugrunde liegende Tabelle oder das darauf aufbauende Formular bemühen. Im vorliegenden Beitrag wollen wir zunächst einmal die Grundlage für die Bearbeitung schaffen – indem wir die Daten der Tabelle per HTML in Kreuztabellenform darstellen.<\/b><\/p>\nBasistabelle<\/h2>\n
Als Basistabelle verwenden wir die Tabelle tblMaterialpreise<\/b>. Diese enthält die Felder MaterialpreisID<\/b>, Breite<\/b>, Hoehe <\/b>und Preis<\/b>. Die Datentypen können Sie dem Tabellenentwurf aus Bild 1 entnehmen.<\/p>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2018_06\/pic_1161_001.png\")
<\/p>\n
Bild 1: Entwurf der Tabelle tblMaterialpreise<\/span><\/b><\/p>\n Hier sehen Sie auch, dass wir für die beiden Felder Hoehe <\/b>und Breite <\/b>einen zusammengesetzten, eindeutigen Index definiert haben. Damit stellen wir sicher, dass für jede Kombination aus Höhe und Breite nur ein Preis festgelegt werden kann – mehr können wir in der Kreuztabelle nicht darstellen.<\/p>\n Die Daten sollen nun so ausgegeben werden, dass die Spaltenüberschriften die Höhe, die Zeilenüberschriften die Breite und die Zellen selbst den jeweiligen Preis für die Kombination aus Höhe und Breite anzeigen. Dazu fügen wir der Tabelle erst einmal ein paar Datensätze zum Spielen hinzu. Die gefüllte Tabelle sieht dann wie in Bild 2 aus.<\/p>\n Bild 2: Beispieldaten in der Tabelle tblMaterialpreise<\/span><\/b><\/p>\n Danach wollen wir zuerst einmal die Daten in Kreuztabellenform im Direktbereich des VBA-Editors ausgeben. Erst nachdem wir den grundlegenden Ablauf programmiert haben, nehmen wir die Darstellung in einer HTML-Tabelle hinzu.<\/p>\n Die Ausgabe im Direktbereich soll durch die Prozedur Kreuztabelle <\/b>erfolgen (siehe Listing 1). Diese definiert eine Variable für das aktuelle Datenbankobjekt (db<\/b>) sowie drei Recordset<\/b>-Variablen. Das Recordset rstSpaltenkoepfe <\/b>nimmt alle Werte des Feldes Hoehe <\/b>der Tabelle tblMaterialpreise <\/b>auf. Damit jeder Wert nur einmal vorkommt, fügen wir neben SELECT <\/b>als zweites Schlüsselwort noch DISTINCT<\/b> hinzu. Auf diese Weise liefert das Recordset jeden Wert des Feldes Hoehe <\/b>nur einmal, hier 800<\/b>, 900 <\/b>und 1.000<\/b>. Außerdem sortieren wir die Werte nach der Größe. Damit können wir schon einmal die Spaltenüberschriften in den Direktbereich schreiben. Hier beginnen wir mit einer leeren Spalte, was wir durch die Ausgabe einer leeren Zeichenkette plus dem Komma-Zeichen (,<\/b>) stellvertretend für einen Tabulator-Schritt erledigen. Dann durchlaufen wir in einer Do While<\/b>-Schleife alle Datensätze des Recordsets rstSpaltenkoepfe <\/b>und geben nacheinander alle Werte in einer Zeile aus. Damit Debug.Print <\/b>nach der Ausgabe eines Wertes nicht in die nächste Zeile springt, hängen wir auch hier jeweils das Komma an. Dadurch wird auch hier ein Tabulator eingefügt statt des üblichen Zeilenumbruchs. Damit wäre die Zeile mit den Spaltenköpfen bereits geschafft. Das Ergebnis sieht bisher so aus:<\/p>\n Listing 1: Ausgabe der Spaltenköpfe, Zeilenköpfe und Preise im Direktbereich<\/span><\/b><\/p>\n Damit wir danach mit der ersten Zeile mit Daten fortfahren können, folgt nun der Aufruf der Debug.Print<\/b>-Anweisung ohne Parameter. Damit springen wir direkt in die nächste Zeile. Das zweite Recordset namens rstZeilen <\/b>füllen wir mit allen Einträgen des Feldes Breite <\/b>der Tabelle tblMaterialpreise<\/b>, diesmal aufsteigend sortiert nach dem Feld Breite<\/b>. Auch hier verwenden wir das DISTINCT<\/b>-Schlüsselwort, damit jede Breite nur einmal aufgenommen wird. Dieses Recordset enthält nun also jeweils einen Datensatz für jede Breite, hier 800<\/b>, 900 <\/b>und 1.000<\/b>.<\/p>\n Dieses Recordset durchlaufen wir nun in der nächsten Do While<\/b>-Schleife und wollen in jedem Durchlauf eine komplette Zeile mit dem Zeilenkopf und den Werten für die Kombination aus Spaltenkopf und Zeilenkopf in den Direktbereich schreiben. Den Zeilenkopf geben wir schon einmal per Debug.Print <\/b>aus, wobei wir dieser als Parameter den Wert rstZeilen!Breite <\/b>plus einem Komma für einen Sprung zur nächsten Tabulatorposition statt in die nächste Zeile.<\/p>\n Außerdem brauchen wir für jede Zeile noch ein weiteres Recordset, das die Werte für die aktuelle Zeile und die jeweilige Spalte abruft. Dieses heißt rstWerte <\/b>und enthält alle Werte des Feldes Preis <\/b>der Tabelle tblMaterialpreise<\/b>, deren Feld Breite <\/b>den Wert des aktuellen Spaltenkopfes enthält – wieder sortiert nach dem Feld Hoehe<\/b>.<\/p>\n Auch diese Werte durchlaufen wir in einer Do While<\/b>-Schleife und geben in dieser jeweils den Inhalt des Feldes Preis aus – gefolgt von einem Komma, damit kein Zeilen-umbruch, sondern ein Sprung an die nächste Tabulator-Stelle erfolgt. Das Ergebnis nach dem Durchlaufen sieht dann wie folgt aus:<\/p>\n Gar nicht schlecht für den Start! Allerdings enthält diese Vorgehensweise eine kleine Schwachstelle. Wir ergänzen die Tabelle tblMaterialpreise <\/b>wie in Bild 3. Wie Sie sehen, haben wir mit 700 <\/b>eine neue Höhe eingeführt, aber nur Werte für die Breiten 800 <\/b>und 1.000 <\/b>angegeben – die Kombination aus 700 <\/b>und 900 <\/b>fehlt. Das Ergebnis im Direktfenster sieht dann wie in Bild 4 aus. Der Preis für die Kombination 700 <\/b>und 900 <\/b>wird einfach weggelassen und die übrigen Kombinationen für die Höhe von 700 mm werden einfach nach links verschoben.<\/p>\n Bild 3: Erweiterte Beispieldaten in der Tabelle tblMaterialpreise<\/span><\/b><\/p>\n Bild 4: Ausgabe der neuen Beispieldaten<\/span><\/b><\/p>\n Wie bekommen wir es also hin, dass alle Kombinationen berücksichtigt werden, auch wenn ein Wert nicht angegeben ist – in der Form, dass die entsprechende Stelle einfach frei gelassen wird<\/p>\n Dazu müssen wir eine kleine Ergänzung vornehmen, und zwar innerhalb der zweiten Do While<\/b>-Schleife (siehe Listing 2). In dieser fügen wie zunächst eine Anweisung ein, welche den Datensatzzeiger des Recordsets, das wir zum Einfügen der Spaltenköpfe verwendet haben, für jeden Datensatz des Recordsets rstZeilen<\/b> auf den ersten Datensatz zurücksetzt (MoveFirst<\/b>). Warum das Weil wir sicherstellen wollen, dass die Markierung im Direktfenster für jeden Spaltenkopf in jeder Zeile auch um eine Tabulatorposition vorrückt – unabhängig davon, ob es auch einen Wert für die Kombination aus den im Spalten- und Zeilenkopf angezeigten Werten gibt. Innerhalb der inneren Do While<\/b>-Schleife, in der wir bisher einfach nur die Werte des Feldes Preis <\/b>in den Direktbereich geschrieben haben, fügen wir nun eine If…Then<\/b>-Bedingung ein, die prüft, ob der Wert des Feldes Hoehe <\/b>des Recordsets rstSpaltenkoepfe <\/b>mit dem des Recordsets rstWerte <\/b>übereinstimmt. Ist dies der Fall, wird der Inhalt des Feldes Preis <\/b>ausgeben und wir gehen mit der MoveNext<\/b>-Methode einen Schritt weiter im Recordset rstWerte<\/b>. Falls nicht, geben wir nur einen Tabulatorschritt im Direktfenster aus. In beiden Fällen bewegen wir den Datensatzzeiger des Recordsets rstSpaltenkoepfe <\/b>um eine Position weiter. Auf diese Weise geben wir für Kombinationen, für die es keinen Preis gibt, einen Tabulatorsprung im Direktbereich aus. Das Ergebnis sieht nun wie in Bild 5 aus.<\/p>\n <\/p>\n Bild 5: Ausgabe der neuen Beispieldaten mit Leerstellen<\/span><\/b><\/p>\n Listing 2: Ausgabe der Spaltenköpfe, Zeilenköpfe und Preise im Direktbereich auch mit leeren Kombinationen<\/span><\/b><\/p>\n Damit können wir die grundlegende Ausgabe als erledigt betrachten und uns der ersten Erweiterung zuwenden – der Ausgabe im HTML-Format im Webbrowser-Steuerelement von Access.<\/p>\n Dazu legen wir ein neues Formular namens frmKreuztabelleHTML <\/b>an und fügen diesem ein Webbrowser<\/b>-Steuerelement aus der Toolbox hinzu. Danach stellen sie noch seine Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>auf den Wert Beide <\/b>ein, damit sich die Größe des Webbrowser-Steuerelements beim Verändern der Größe des Formulars an dieses anpasst (siehe Bild 6).<\/p>\n Bild 6: Hinzufügen des Webbrowser-Steuerelements<\/span><\/b><\/p>\n Dann wollen wir zunächst dafür sorgen, dass beim öffnen des Formulars eine leere Webseite erscheint. Dazu fügen wir dem VBA-Projekt der Anwendung zunächst einen Verweis auf die Bibliothek Microsoft HTML Object Library<\/b> hinzu – und zwar über den Dialog, den Sie mit dem Menübefehl Extras|Verweise <\/b>öffnen (siehe Bild 7). Danach legen wir eine neue Ereignisprozedur für das Ereignis Beim öffnen <\/b>des Formulars an. Die dort verwenden Variablen deklarieren wir im allgemeinen Teil des Klassenmoduls des Formulars:<\/p>\n Bild 7: Verweis auf die Bibliothek Microsoft HTML Object Library<\/span><\/b><\/p>\n Die erste Variable nimmt einen Verweis auf das Web-browser-Steuerelement auf, die zweite einen auf das darin angezeigte Dokument. Die Variablen füllen wir mit der Ereignisprozedur Form_Open<\/b>, die wir wie folgt erweitern:<\/p>\n Die Prozedur weist zuerst der Variablen objWebbrowser <\/b>den Verweis auf das Webbrowser-Steuerelement zu. Wir könnten nun direkt mit der Navigate<\/b>-Methode den Wert about:blank <\/b>als Zielseite einstellen. Allerdings führt das manchmal zu Problem. Abhilfe schafft dann das verzögerte Laden dieser Seite, also aktivieren wir hier den Timer für das Formular, indem wir die Eigenschaft TimerInterval <\/b>auf den Wert 300 <\/b>einstellen (das entspricht 300 Millisekunden).<\/p>\n Erst in der für das Ereignis Bei Zeitgeber <\/b>angegebenen Ereignisprozedur navigiert sie mit der Navigate<\/b>-Methode zu einer leeren Seite namens about:blank<\/b>. Außerdem setzen wir noch die Variable objDocument <\/b>auf das im Webbrowser angezeigte Dokument. Schließlich setzen wir Me.TimerInterval <\/b>auf den Wert 0<\/b>, damit der Zeitgeber deaktiviert wird.<\/p>\n Damit erhalten wir nach dem öffnen des Formulars das Bild aus Bild 8.<\/p>\n Bild 8: Leeres Webbrowser-Steuerelement<\/span><\/b><\/p>\n Nun wollen wir die Ausgabe, die wir bereits in den Direktbereich vorgenommen haben, an den Browser schicken. Dazu bedarf es noch einiger Erweiterungen, nämlich in Form von HTML-Tags. Dabei wollen wir gar nicht erst damit anfangen, HTML in Form einer Zeichenkette zusammenzustellen und dann dem Dokument als Inhalt zuzuweisen. Wir wollen gleich auf der Objekt-Ebene arbeiten und damit die Grundlage schaffen, später auf Ereignisse der Elemente reagieren zu können. Dafür ist zwar noch ein weiterer Schritt nötig, aber die nachfolgend beschriebene Prozedur zeigt, wie Sie ein HTML-Dokument auf Basis von HTML-Objekten aufbauen. Hier kommt nun auch der Verweis auf die Bibliothek Microsoft HTML Object Library<\/b> zum Tragen, den wir bereits weiter oben angelegt haben. Die neue Funktion KreuztabelleErstellen <\/b>rufen wir von der Ereignisprozedur Form_Timer <\/b>auf, die wir wie folgt ergänzen:<\/p>\n Die Prozedur aus Listing 3 verwendet einige neue Variablen, welche die Verweise auf die erstellten Objekt wie die HTML-Tabelle, die Zeile und die Zelle aufnehmen:<\/p>\n Listing 3: Ausgabe der Spaltenköpfe, Zeilenköpfe und Preise als HTML-Objekte<\/span><\/b><\/p>\n Nach dem obligatorischen Erstellen des Verweises auf die aktuelle Datenbank erstellen wir mit der createElement<\/b>-Methode des Objekts objDocument <\/b>ein neues Table<\/b>-Element. Dieses schwebt noch im luftleeren Raum, daher müssen wir es noch dem body<\/b>-Element des Dokuments hinzufügen, und zwar als Parameter der appendChild<\/b>-Methode. Danach legen wir eine neue Zeile an (die erste) und eine neue Zelle (ebenfalls die erste, nämlich die, welche oben links die Spalten- und die Zellenüberschriften kreuzt). Dazu nutzen wir die insertRow<\/b>-Methode des objTable<\/b>-Objekts, deren Ergebnis wir in der Variablen objRow <\/b>speichern. Die neue Zelle fügen wir dann dem objRow<\/b>-Objekt über seine Methode insertCell <\/b>hinzu und referenzieren es mit der Variablen objCell<\/b>.<\/p>\n Danach fügen wir die Spaltenüberschriften ein, und zwar in der gleichen Do While<\/b>-Schleife wie in der vorherigen Prozedur. Hier kommt dann in jedem Durchlauf die insertCell<\/b>-Methode zum Einsatz, die jeweils eine neue Zelle hinzufügt. Diese sollen aber nicht mehr leer sein, sondern die Spaltenüberschrift anzeigen. Dazu weisen wir der Eigenschaft innerText <\/b>des jeweils neu hinzugefügten Objekts den Namen der Spalte zu, in dem Fall entnommen aus dem Feld Hoehe <\/b>des Recordsets rstSpaltenkoepfe<\/b>. Danach folgt die verschachtelte Do While<\/b>-Schleife, in der wir die weiteren Zeilen und Zellen zum HTML-Dokument hinzufügen. Hier kommen wieder die beiden Methoden insertRow <\/b>und insertCell <\/b>zum Einsatz. Der Aufbau der beiden Do While<\/b>-Schleifen entspricht dem im vorherigen Beispiel. Wir legen also immer erst eine neue Zeile an und fügen dann die Zellen zu dieser Zeile hinzu. Daraus entsteht dann die Kreuztabelle aus Bild 9. Die Ansicht ist natürlich noch nicht besonders hübsch, also fügen wir noch ein paar Formatierungen hinzu.<\/p>\n Bild 9: Kreuztabelle im Webbrowser-Steuerelement<\/span><\/b><\/p>\n Um Formatierungen mit CSS hinzuzufügen, benötigen wir zwei Dinge: Eine Datei oder einen String mit den CSS-Formatierungen und Auszeichnungen der zu formatierenden Elemente, die dann in den CSS-Formatierungen referenziert werden. Bei diesen Auszeichnungen kann es sich ganz allgemein um die Elementnamen handeln, also etwa TABLE<\/b>, TR <\/b>oder TD<\/b>. Es kann aber auch eine spezielle Auszeichnung sein, die durch die Eigenschaft className <\/b>für das jeweilige Element festgelegt wird. Im Folgenden haben wir die Prozedur KreuztabelleErstellen <\/b>entsprechend angepasst. Die ersten Zeilen deklarieren und erstellen ein Objekt, das die CSS-Definitionen aufnehmen wird. Dieses legen wir mit der Methode createStyleSheet <\/b>als neues Objekt an. Dann weisen wir seiner Eigenschaft cssText <\/b>den Wert der Funktion CSS <\/b>zu:<\/p>\n Für das Table<\/b>-Element, das eine eigene CSS-Auszeichnung enthalten wird, die alle grundlegenden Definitionen enthält, brauchen wir nichts weiter zu tun:<\/p>\n Das Cell<\/b>-Objekt oben links statten wir mit den beiden Klassen columnHeader <\/b>und rowHeader <\/b>aus:<\/p>\n Dadurch soll es später die Eigenschaften übernehmen, die wir für diese beiden Klassen festlegen. Im Wesentlichen wird das ein Rahmen links (columnHeader<\/b>) und ein Rahmen oben (rowHeader<\/b>) sein. Die übrigen Elemente, die als Spaltenköpfe dienen, definieren wir mit der Klasse columnHeader<\/b>:<\/p>\n Schließlich fehlen noch die Zeilenköpfe, die wir als rowHeader <\/b>markieren:<\/p>\n Der HTML-Code sieht für unsere Beispieldaten nun wie folgt aus – hier können Sie erkennen, welche Elemente welchen Elementtyp aufweisen und mit welcher Klasse diese versehen sind:<\/p>\n Die CSS-Definition stellen wir in einer eigenen String-Funktion zusammen, die wir CSS <\/b>nennen. Sie sieht wie folgt aus und definiert zunächst die Eigenschaften, die tabellenweit gelten sollen – dementsprechend legen wir diese für das Element table <\/b>fest. Hier definieren wir die Schriftart (Calibri<\/b>), die Textausrichtung (center<\/b>) sowie die Breite der Tabelle gemessen an der HTML-Seite (100%<\/b>, also Ausdehnung über den gesamten Browser) und legen fest, dass Rahmen von zwei benachbarten Elementen zusammengefasst werden sollen (border-collapse: collapse<\/b>):<\/p>\n Danach geht es weiter mit der Klasse columnHeader <\/b>für die td<\/b>-Elemente. Diese legt fest, dass der enthaltene Text fett ausgegeben werden soll (font-weight: bold<\/b>) und dass der untere Rand der Zelle mit einer Linie der Breite 1px <\/b>versehen werden soll – diese soll durchgezogen sein (Daten in Kreuztabellenform ausgeben<\/h2>\n
![\"Beispieldaten](\"..\/fileadmin\/_temp_\/2018_06\/pic_1161_002.png\")
<\/p>\nPublic Sub <\/span>Kreuztabelle()\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 Set<\/span> db = CurrentDb\r\n Set<\/span> rstSpaltenkoepfe = db.OpenRecordset(\"SELECT DISTINCT Hoehe FROM tblMaterialpreise ORDER BY Hoehe\", dbOpenDynaset)\r\n Debug.Print<\/span> ,\r\n Do While<\/span> Not<\/span> rstSpaltenkoepfe.EOF\r\n Debug.Print<\/span> rstSpaltenkoepfe!Hoehe,\r\n rstSpaltenkoepfe.MoveNext<\/span>\r\n Loop<\/span>\r\n Debug.Print<\/span>\r\n Set<\/span> rstZeilen = db.OpenRecordset(\"SELECT DISTINCT Breite FROM tblMaterialpreise ORDER BY Breite\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstZeilen.EOF\r\n Debug.Print<\/span> rstZeilen!Breite,\r\n Set<\/span> rstWerte = db.OpenRecordset(\"SELECT Preis FROM tblMaterialpreise WHERE Breite = \" & rstZeilen!Breite _\r\n & \" ORDER BY Hoehe\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstWerte.EOF\r\n Debug.Print<\/span> rstWerte!Preis,\r\n rstWerte.MoveNext<\/span>\r\n Loop<\/span>\r\n Debug.Print<\/span>\r\n rstZeilen.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\n 800 900 1000 <\/pre>\n
800 900 1000 \r\n 800 64 72 80 \r\n 900 72 81 90 \r\n 1000 80 90 100 <\/pre>\n
![\"Erweiterte](\"..\/fileadmin\/_temp_\/2018_06\/pic_1161_003.png\")
<\/p>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2018_06\/pic_1161_004.png\")
<\/p>\nAlle Kombinationen ohne Ausnahme ausgeben<\/h2>\n
![\"Ausgabe](\"..\/fileadmin\/_temp_\/2018_06\/pic_1161_005.png\")
<\/p>\nPublic Sub <\/span>Kreuztabelle()\r\n ''''... wie in der ersten Fassung\r\n Set<\/span> rstZeilen = db.OpenRecordset(\"SELECT DISTINCT Breite FROM tblMaterialpreise ORDER BY Breite\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstZeilen.EOF\r\n rstSpaltenkoepfe.MoveFirst\r\n Debug.Print<\/span> rstZeilen!Breite,\r\n Set<\/span> rstWerte = db.OpenRecordset(\"SELECT Preis, Hoehe FROM tblMaterialpreise WHERE Breite = \" _\r\n & rstZeilen!Breite & \" ORDER BY Hoehe\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstWerte.EOF\r\n If <\/span>rstSpaltenkoepfe!Hoehe = rstWerte!Hoehe Then<\/span>\r\n Debug.Print<\/span> rstWerte!Preis,\r\n rstWerte.MoveNext<\/span>\r\n Else<\/span>\r\n Debug.Print<\/span> ,\r\n End If<\/span>\r\n rstSpaltenkoepfe.MoveNext<\/span>\r\n Loop<\/span>\r\n Debug.Print<\/span>\r\n rstZeilen.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nWebbrowser-Steuerelement anlegen<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2018_06\/pic_1161_006.png\")
<\/p>\n![\"Verweis](\"..\/fileadmin\/_temp_\/2018_06\/pic_1161_007.png\")
<\/p>\nDim <\/span>WithEvents objWebbrowser As <\/span>WebBrowser\r\nDim <\/span>objDocument As <\/span>HTMLDocument<\/pre>\nPrivate Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Set<\/span> objWebbrowser = Me!ctlWebbrowser.Object\r\n Me.TimerInterval = 300\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\nEnd Sub<\/span><\/pre>\n![\"Leeres](\"..\/fileadmin\/_temp_\/2018_06\/pic_1161_008.png\")
<\/p>\nFüllen mit HTML-Kreuztabelle<\/h2>\n
Private 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 KreuztabelleErstellen\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>KreuztabelleErstellen()\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 Set<\/span> db = CurrentDb\r\n Set<\/span> objTable = objDocument.createElement(\"Table\")\r\n objDocument.body.appendChild objTable\r\n Set<\/span> rstSpaltenkoepfe = db.OpenRecordset(\"SELECT DISTINCT Hoehe FROM tblMaterialpreise ORDER BY Hoehe\", dbOpenDynaset)\r\n Set<\/span> objRow = objTable.insertRow\r\n Set<\/span> objCell = objRow.insertCell\r\n Do While<\/span> Not<\/span> rstSpaltenkoepfe.EOF\r\n Set<\/span> objCell = objRow.insertCell\r\n objCell.innerText = rstSpaltenkoepfe!Hoehe\r\n rstSpaltenkoepfe.MoveNext<\/span>\r\n Loop<\/span>\r\n Set<\/span> rstZeilen = db.OpenRecordset(\"SELECT DISTINCT Breite FROM tblMaterialpreise ORDER BY Breite\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstZeilen.EOF\r\n Set<\/span> objRow = objTable.insertRow\r\n rstSpaltenkoepfe.MoveFirst\r\n Set<\/span> objCell = objRow.insertCell\r\n objCell.innerText = rstZeilen!Breite\r\n Set<\/span> rstWerte = db.OpenRecordset(\"SELECT Preis, Hoehe FROM tblMaterialpreise WHERE Breite = \" _\r\n & rstZeilen!Breite & \" ORDER BY Hoehe\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstWerte.EOF\r\n If <\/span>rstSpaltenkoepfe!Hoehe = rstWerte!Hoehe Then<\/span>\r\n Set<\/span> objCell = objRow.insertCell\r\n objCell.innerText = rstWerte!Preis\r\n rstWerte.MoveNext<\/span>\r\n Else<\/span>\r\n Set<\/span> objCell = objRow.insertCell\r\n End If<\/span>\r\n rstSpaltenkoepfe.MoveNext<\/span>\r\n Loop<\/span>\r\n rstZeilen.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nDim <\/span>objTable As <\/span>MSHTML.HTMLTable\r\nDim <\/span>objRow As <\/span>MSHTML.HTMLTableRow\r\nDim <\/span>objCell As <\/span>MSHTML.HTMLTableCell<\/pre>\n![\"Kreuztabelle](\"..\/fileadmin\/_temp_\/2018_06\/pic_1161_009.png\")
<\/p>\nCSS-Formatierungen hinzufügen<\/h2>\n
Private Sub <\/span>KreuztabelleErstellen()\r\n ...\r\n Dim <\/span>objCSS As Object<\/span>\r\n Set<\/span> objCSS = objDocument.createStyleSheet(\"\")\r\n objCSS.cssText = CSS\r\n ...<\/pre>\n Set<\/span> objTable = objDocument.createElement(\"Table\")\r\n ...<\/pre>\n Set<\/span> objCell = objRow.insertCell\r\n objCell.className = \"columnHeader rowHeader\"<\/pre>\n Do While<\/span> Not<\/span> rstSpaltenkoepfe.EOF\r\n Set<\/span> objCell = objRow.insertCell\r\n objCell.className = \"columnHeader\"\r\n ...\r\n Loop<\/span>\r\n ...<\/pre>\n Do While<\/span> Not<\/span> rstZeilen.EOF\r\n ...\r\n Set<\/span> objCell = objRow.insertCell\r\n objCell.className = \"rowHeader\"\r\n ...\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nDer resultierende HTML-Code<\/h2>\n
<table>\r\n <tbody>\r\n <tr>\r\n <td class=\"header rowheader\"><\/td>\r\n <td class=\"header\">700<\/td>\r\n ...\r\n <\/tr>\r\n <tr>\r\n <td class=\"rowheader\">800<\/td>\r\n <td>56<\/td>\r\n ...\r\n <\/tr>\r\n ...\r\n <\/tbody>\r\n<\/table><\/pre>\n
Die CSS-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 & \"}\"<\/pre>\n