<\/p>\n
Die Datenblatt-Ansicht und das Endlosformular sind gute Helfer, wenn es um die Anzeige mehrerer Datensätze einer Tabelle oder Abfrage geht. Allerdings haben beide einen gravierenden Nachteil: Sie zeigen alle Datensätze immer in der gleichen Höhe an. Wenn also ein Datensatz etwa eine Notiz enthält, die nur eine Zeile lang ist, eine andere aber zehn Zeilen, müssen Sie die Formularhöhe nach dem längsten Inhalt auslegen. Dadurch verlieren Sie wiederum eine Menge Platz, da die Höhe ja auch für kurze Inhalte beansprucht wird. Dieser Beitrag zeigt, wie Sie das Problem mithilfe von HTML und dem Webbrowser-Steuerelement beheben.<\/b><\/p>\nBeispieltabelle<\/h2>\n
Als Beispiel für die Anzeige und Bearbeitung von Daten in einem Webbrowser-Steuerelement verwenden wir die Tabelle tblNotizen<\/b>. Diese enthält neben dem Primärschlüsselfeld NotizID <\/b>noch die beiden Felder Notiz <\/b>mit dem eigentlichen Inhalt (ausgelegt als Memo-Feld, also mit ausreichend Platz) sowie ein Feld namens AngelegtAm<\/b>.<\/p>\nWebbrowser-Steuerelement einbauen<\/h2>\n
Das Formular mit dem ersten Beispiel soll frmNotizen <\/b>heißen. Dass das Formular seine Daten in einem Webbrowser-Steuerelement anzeigen soll und keine eigenen Datensätze, können Sie die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Bildlaufleisten <\/b>und Trennlinien <\/b>auf den Wert Nein <\/b>einstellen.<\/p>\n
Fügen Sie dem Formular dann das Webbrowser-Steuerelement hinzu und nennen Sie es ctlWebbrowser<\/b> (s. Bild 1).<\/p>\n
![\"Einfügen](\"..\/fileadmin\/_temp_\/2016_02\/pic_1029_001.png\")
<\/p>\n
Bild 1: Einfügen und Anpassen des Webbrowser-Steuerelements<\/span><\/b><\/p>\n Stellen Sie seine Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>jeweils auf den Wet Beide <\/b>ein. Auf diese Weise passt es seine Größe automatisch an die Größe des Formulars an.<\/p>\n Bevor wir richtig loslegen, fügen Sie dem VBA-Projekt der Datenbank noch einen Verweis auf die Bibliothek Microsoft HTML Object Library <\/b>hinzu (s. Bild 2). Den Verweise<\/b>-Dialog des VBA-Editors öffnen Sie mit dem Menübefehl Extras|Verweise<\/b>.<\/p>\n Bild 2: Zusätzlicher Verweis auf die Bibliothek Microsoft HTML Object Library<\/span><\/b><\/p>\n Diese Bibliothek steuert die Elemente für die VBA-Programmierung des HTML-Dokuments bei – wir können damit vollständige Internetseiten nicht nur definieren, sondern auch steuern, also beispielsweise auf die Ereignisse der einzelnen Elemente der HTML-Seite reagieren. Dies ist wichtig, wenn wir etwa durch einen Mausklick auf einen Datensatz ein Detailformular zum Bearbeiten der Daten dieses Datensatzes aufrufen möchten.<\/p>\n Bevor wir mit der Programmierung des Formulars und des Webbrowser-Steuerelements beginnen, wollen wir noch die Tabelle tblNotizen<\/b> mit einigen Datensätzen füllen. Die Tabelle sieht anschließend wie in Bild 3 aus.<\/p>\n Bild 3: Beispieldaten für die Tabelle tblNotizen<\/span><\/b><\/p>\n Das Webbrowser-Steuerelement soll die Daten der Tabelle tblNotizen <\/b>anzeigen und bei Betätigen der Taste F5 <\/b>wie ein herkömmliches Formular seine Daten aktualisieren. Wenn Sie also das Formular geöffnet haben und dann beispielsweise im Hintergrund einen Datensatz direkt in der Tabelle verändern, soll die Taste F5 <\/b>zur Anzeige der geänderten Daten im Webbrowser-Steuerelement führen.<\/p>\n Damit wir auf alle Ereignisse rund um das Webbrowser-Steuerelement und das enthaltene Dokument in Form der Implementierung geeigneter Ereignisprozeduren reagieren können, deklarieren wir sowohl für das Webbrowser-Steuerelement als auch für das darin angezeigte Dokument je eine Variable mit dem Schlüsselwort WithEvents<\/b>:<\/p>\n Beim Laden des Formulars sind einige vorbereitende Aktionen durchzuführen. Diese implementieren wir in Form einer Ereignisprozedur, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird. Diese Prozedur sieht wie folgt aus:<\/p>\n Die erste Anweisung setzt die Objektvariable objWeb-brow-ser<\/b> auf das im Webbrowser-Steuerelement enthaltene Objekt. Die zweite ruft eine Prozedur namens Web-browserLeeren <\/b>auf, die das Steuerelement mit einer leeren HTML-Seite füllt und erst zur aufrufenden Prozedur zurückwechselt, wenn dieser Vorgang ausgeführt wurde. Dazu durchläuft die Prozedur eine Do While<\/b>-Schleife, deren Abbruchbedingung die Eigenschaft ReadyState <\/b>des Webbrowser-Steuerelements mit dem Wert READYSTATE_COMPLETE <\/b>vergleicht:<\/p>\n Diese Bedingung wird erfüllt, wenn die Seite von der angegebenen Adresse, hier about:blank <\/b>für eine leere Seite, vollständig geladen wurde. Danach fügt die Prozedur Form_Load <\/b>noch eine einzelne, leere Zeile zum Dokument hinzu (objWebbrowser.Document.Write „“<\/b>).<\/p>\n Das waren bereits die Vorbereitungen und wir können mit dem Füllen der Seite mit den eigentlichen Inhalten beginnen, damit diese wie in Bild 4 im Webbrowser-Steuer-element erscheinen. Aber wann sollen diese nun geladen werden – und welches Ereignis löst diesen Vorgang aus Da wir, wie weiter oben beschrieben, den Inhalt des Webbrowser-Steuerelements beim Betätigen von F5 <\/b>ebenfalls aktualisieren wollen, wäre die durch das Ereignis Beim Anzeigen <\/b>ausgelöste Prozedur der richtige Ort. Also fügen wir dort den Aufruf der Routine zum Anzeigen der Daten ein:<\/p>\n Bild 4: Anzeige der Daten im Webbrowser-Steuerelement<\/span><\/b><\/p>\n Außerdem hinterlegen wir dort noch einen Befehl, der nach Füllen des Webbrowser-Steuerelements einmal den HTML-Inhalt des angezeigten Dokuments im Direktfenster ausgibt – einfach, damit Sie einmal kontrollieren können, wie der erzeugte Code aussieht. Mit dem Kontextmenü-befehl Quellcode anzeigen <\/b>des Webbrowser-Steuerelements erhalten Sie nämlich lediglich den Text <\/html><\/b>, was wenig hilfreich ist.<\/p>\n Die Prozedur DatenAnzeigen<\/b> finden Sie in Listing 1. Sie deklariert zunächste einige Elemente, welche die im Webbrowser-Steuerelement angezeigten Objekte repräsentieren. Als Erstes benötigen wir, um die Struktur einer Tabelle abzubilden, ein Objekt des Typs HTMLTable<\/b>, das wir mit der Variablen objTable <\/b>deklarieren. Außerdem benötigen wir ein HTMLTableRow<\/b>-Objekt (objRow<\/b>) und ein HTMLTableCell<\/b>-Objekt (objCell<\/b>).<\/p>\n Listing 1: Füllen des Webbrowser-Steuerelements mit den Daten der Tabelle tblNotizen<\/span><\/b><\/p>\n Daneben müssen wir natürlich auf die aktuelle Datenbank sowie die Tabelle tblNotizen <\/b>zugreifen, daher deklarieren wir ein entsprechendes Objekt des Typs Database <\/b>(db<\/b>) und eines des Typs Recordset <\/b>(rst<\/b>).<\/p>\n Das Webbrowser-Steuerelement referenzieren wir hier nur aus dem Grund erneut mit der Variablen objWebbrowser<\/b>, weil sich dies bei Experimenten und den dabei auftretenden unbehandelten Fehlern schon einmal leert und dies dann zu einem weiteren Fehler führt. Dann füllen wir die Variable objDocument <\/b>mit einem Verweis auf das im Webbrowser angezeigte Dokument (objWebbrowser.Document<\/b>).<\/p>\n Die Vorbereitungen für den Zugriff auf die Tabelle tblNotizen <\/b>enthalten das Füllen der Variablen db <\/b>mit dem Database<\/b>-Objekt der aktuellen Datenbank mit CurrentDb<\/b>, und die OpenRecordset<\/b>-Methode versieht die Variable rst <\/b>mit einem Recordset auf Basis der Tabelle tblNotizen<\/b>.<\/p>\n Danach ruft die Prozedur erneut die Routine WebbrowserLeeren <\/b>auf und leert auch noch das Document<\/b>-Objekt mit der Clear<\/b>-Methode.<\/p>\n Schließlich beginnt das eigentliche Füllen des Dokuments, zunächst mit einem Table<\/b>-Element. Das Element erstellt die Prozedur mit der createElement<\/b>-Methode und dem Namen des zu erstellenden Objekts als Parameter (Table). Dieses Element fügt die appendChild<\/b>-Methode des Body<\/b>-Elements des Dokuments dann in den Body des Dokuments ein. Der HTML-Code sieht an dieser Stelle wie folgt aus:<\/p>\n Nun stellen wir die Eigenschaft Style.borderCollapse <\/b>auf collapse<\/b> ein, was bewirkt, dass die Rahmen der verschiedenen Zellen der Tabelle miteinander verschmelzen und nicht jede Zelle einen eigenen Rahmen erhält.<\/p>\n Nun kommt die Prozedur zu den Zeilen und Spalten, zuerst mit der Kopfzeile, welche die Spaltenüberschriften enthalten und anders formatiert sein soll. Diese fügen wir mit der insertRow<\/b>-Methode des HTMLTable<\/b>-Objekts aus objTable <\/b>ein und referenzieren es mit der Variablen objRow<\/b>. Wir benötigen zwei Spalten, eine für das Feld AngelegtAm <\/b>und eine für das Feld Notiz<\/b>. Die Zelle der Kopfzeile für das Feld AngelegtAm <\/b>fügt die Prozedur mit der Methode insertCell <\/b>des soeben erzeugten Elements objRow <\/b>an und speichert den Verweis darauf in der Variablen objCell<\/b>. Für dieses Objekt rufen wir einmal die Routine FormatHeader <\/b>auf und übergeben dieser den Verweis auf die Zelle, dann fügen wir der Eigenschaft innerText <\/b>den Ausdruck Datum: <\/b>hinzu, also den Text für die Spaltenüberschrift.<\/p>\n Die Routine FormatHeader <\/b>nimmt den Verweis auf die zu formatierende Zelle entgegen und weist dann verschiedenen Eigenschaften des Style<\/b>-Objekts der Zelle die gewünschten Werte zu. BorderColor <\/b>und BackgroundColor <\/b>erhalten die Schrift- und die Hintergrundfarbe, BorderWidth <\/b>die Rahmendicke, BorderStyle <\/b>die Rahmenart (hier solid <\/b>für einen durchgezogenen Rahmen).<\/p>\n Die horizontale Ausrichtung stellt die Eigenschaft TextAlign <\/b>mit center <\/b>als zentriert ein, die vertikale Ausrichtung übernimmt die Eigenschaft verticalAlign <\/b>mit dem Wert top<\/b>. FontSize<\/b>, FontFamily <\/b>und FontWeight <\/b>definieren das Aussehen der Schrift. Padding <\/b>legt schließlich fest, dass der Text einen Abstand von 5 <\/b>zum linken, oberen, rechten und unteren Rand erhalten soll:<\/p>\n Die Prozedur DatenAnzeigen <\/b>führt dann den gleichen Vorgang für die Spaltenüberschrift mit dem Text Notiz: <\/b>durch und ruft auch hier wieder die Routine FormatHeader <\/b>auf.<\/p>\n Danach folgen die eigentlichen Daten, welche die Prozedur in einer Do While<\/b>-Schleife über alle Datensätze des Recordsets rst <\/b>durchläuft. Dabei trifft die Prozedur zunächst die Vorbereitung für die Anzeige der einzelnen Zeilen mit wechselnden Hintergrundfarben. Dies betrifft nicht nur die Hintergrundfarbe, sondern auch die Rahmenfarbe, weshalb wir die zu verwendenden Farben in zwei Variablen namens strBackgroundColor <\/b>und strBorderColor <\/b>speichern. Hier stehen die beiden Farben #FFFFFF <\/b>(weiß) und #EEEEEE <\/b>(hellgrau) zur Auswahl, wobei diese wechselseitig zum Einsatz kommen sollen (also weißer Hintergrund\/hellgrauer Rahmen und hellgrauer Hintergrund\/weißer Rahmen).<\/p>\n Ob die erste oder die zweite Variante gewählt werden soll, ermitteln wir mit dem Ausdruck rst.AbsolutePosition Mod 2 = 0<\/b>. Dies ergibt bei geraden Werten für rst.AbsolutePosition <\/b>(also der aktuellen Position des Datensatzzeigers mit dem Wert 0 <\/b>für den ersten Datensatz) den Wert True <\/b>und bei ungeraden Werten den Wert False<\/b>, sodass die beiden Variablen strBackgroundColor <\/b>und strBorderColor <\/b>abwechselnd mit den Werten #FFFFFF <\/b>und #EEEEEE <\/b>gefüllt werden.<\/p>\n Nach dem Anlegen der Zeile für den aktuellen Datensatz mit der insertRow<\/b>-Methode und dem Erstellen der Zelle für das Anlagedatum mit insertCell <\/b>ruft die Prozedur diesmal die Routine FormatCell <\/b>auf. Diese finden Sie in Listing 2. Die Routine erwartet nicht nur einen Verweis auf die zu formatierende Zelle, sondern optional noch Werte für die beiden Parameter strBackgroundColor <\/b>und strBorderColor<\/b>. Sie prüft zuerst, ob der Parameter strBackgroundColor <\/b>gefüllt ist. Falls ja, erhält die Eigenschaft BackgroundColor <\/b>den Wert dieses Parameters, anderenfalls den Standardwert #FFFFFF<\/b>. Das Gleiche erledigt die Prozedur für den Parameter strBorderColor <\/b>und die Eigenschaft BorderColor <\/b>der Zelle. Schließlich stellt sie die übrigen Eigenschaften der Zelle ein, die Sie bereits weiter oben kennen gelernt haben (mit kleinen Unterschieden – zum Beispiel soll die Schrift nicht fett dargestellt werden, dafür aber links ausgerichtet).<\/p>\n Listing 2: Formatieren der Zellen mit den Daten der Tabelle tblNotizen<\/span><\/b><\/p>\n Die Eigenschaft innerText <\/b>füllt die Prozedur mit dem Wert des Feldes AngelegtAm<\/b>. Außerdem schreibt sie den Primärschlüsselwert des aktuellen Datensatzes in die Eigenschaft ID <\/b>der Zelle – dies ist eine vorbereitende Maßnahme für weitere Funktionen. Das Erstellen und Füllen der Zelle mit dem Inhalt des Feldes Notiz <\/b>verläuft analog zum Füllen der Zelle mit dem Anlagedatum. Diese Schritte wiederholt die Prozedur für alle Datensätze des Recordsets rst <\/b>und füllt so die Tabelle mit den gewünschten Daten.<\/p>\n Wenn der Benutzer die Taste F5 <\/b>betätigt, sollen die im Webbrowser-Steuerelement angezeigten Daten aktualisiert werden. Dies ist der erste Fall, in dem wir ein Ereignis des HTMLDocument<\/b>-Objekts implementieren wollen. Es handelt sich um das Ereignis Bei Taste ab<\/b>, das Sie anlegen, indem Sie im Codefenster des Klassenmoduls des Formulars mit dem linken Kombinationsfeld den Eintrag objDocument<\/b> und mit dem rechten den Wert onkeydown <\/b>auswählen (s. Bild 5). Die nun im Codefenster erscheinende Prozedur objDocument_onkeydown <\/b>füllen Sie wie folgt:<\/p>\n Bild 5: Anlegen eines Ereignisses für das Objekt objDocument<\/span><\/b><\/p>\n <\/p>\n Die Prozedur prüft, ob der Benutzer die Taste F5 <\/b>gedrückt hat, was dem Wert 116 <\/b>für den Wert keyCode <\/b>des Objekts objDocument.parentWindow.event <\/b>entspricht. In diesem Fall ruft die Prozedur erneut die Routine DatenAnzeigen <\/b>auf und füllt das Webbrowser-Steuerelement erneut.<\/p>\n Der mit dieser Prozedur erzeugte HTML-Quellcode des im Webbrowser-Steuerelement angezeigten Dokuments sieht nun in gekürzter Fassung wie in Listing 3 aus.<\/p>\n Listing 3: Quellcode der erzeugten HTML-Seite<\/span><\/b><\/p>\n Nun hilft uns die Anzeige der reinen Daten insofern weiter, als dass wir diese nun ohne unnötige Zwischenräume präsentiert bekommen, die durch die unterschiedlich langen Inhalte des Feldes Notiz auftreten. Allerdings können wir im Datenblatt als auch im Endlosformular immer noch die Daten bearbeiten. Diese Möglichkeit wollen wir auch hier anbieten – allerdings in etwas anderer Form, nämlich über ein Detailformular, das beim Anklicken eines bestimmten Bereichs des zu bearbeitenden Datensatzes geöffnet wird. Das Detailformular ist ein einfaches Formular, das einen Datensatz der zugrunde liegenden Tabelle zum Bearbeiten öffnet.<\/p>\n Nun müssen wir uns nur noch entscheiden, wie der Benutzer das Detailformular mit dem gewünschten Datensatz öffnen soll.<\/p>\n Am intuitivsten wäre wohl eine kleine Schaltfläche mit einem Bearbeiten-Symbol für jeden einzelnen Datensatz. Zusätzlich können wir dem Benutzer auch noch ermöglichen, den zu bearbeitenden Datensatz durch einen Doppelklick auf eine der Zellen des betroffenen Datensatzes im Detailformular anzuzeigen. Außerdem benötigen wir natürlich noch eine Schaltfläche, mit der wir das Detailformular zum Anlegen eines neuen Datensatzes öffnen können, und eine Schaltfläche je Datensatz, über die der Benutzer den Datensatz löschen kann.<\/p>\n Wir haben ja bereits die beiden Objekte HTMLTableRow <\/b>und HTMLTableCell <\/b>mit den Objektvariablen objRow <\/b>und objCell <\/b>referenziert. Diese Variablen können wir auch mit dem Schlüsselwort WithEvents <\/b>versehen und damit dafür sorgen, dass wir deren Ereignisse unter VBA implementieren können. Wir können dann so beispielsweise ein Ereignis behandeln, das durch einen Doppelklick auf ein HTMLTableCell<\/b>-Objekt ausgelöst wird. Oder wir fügen der Tabelle noch ein oder zwei Spalten hinzu, die Icons beziehungsweise Schaltflächen zum Ausführen von Aktionen wie dem Bearbeiten oder Löschen aufnehmen.<\/p>\n Im Detail sieht das so aus wie in Bild 6. Hier haben wir etwa durch einen Doppelklick auf eines der HTMLTableCell<\/b>-Objekte ein Ereignis ausgelöst, für das wir eine MsgBox<\/b>-Anweisung hinterlegt haben. Die Schaltflächen rechts lösen beim einfachen Anklicken Ereignisprozeduren aus.<\/p>\n Bild 6: Anzeigen eines Meldungsfensters beim Doppelklick auf einen Eintrag<\/span><\/b><\/p>\n Nun wäre es einfach, eine einzelne Zelle mit einer mit dem Schlüsselwort WithEvents <\/b>gekennzeichneten Variablen zu referenzieren und dafür eine Ereignisprozedur zu hinterlegen. Wir haben aber bereits in dieser einfachen Darstellung in jeder Zeile zwei Zellen, die wir mit Doppelklick-Ereignissen ausstatten müssten – und noch je zwei weitere Icons, die bei einem einfachen Mausklick ihre Ereignisse auslösen sollen. Und da wir diese Menge Objektvariablen auch noch für jeden einzelnen Datensatz benötigen, obwohl wir noch nicht einmal wissen, um wie viele Datensätze es sich hier handelt, können wir kaum mit statischem Code arbeiten: Wir müssen zur Laufzeit beim Füllen des Webbrowser-Steuerelements für jedes zu berücksichtigende Steuerelement ein Objekt auf Basis einer Klasse erstellen, die alle notwendigen Eigenschaften aufnimmt und die Ereignisprozeduren enthält. Diese sollen nach dem Erstellen in einer Collection landen, damit sie nicht im Nirwana verschwinden. Dieses Collection<\/b>-Objekt deklarieren wir wie folgt im Kopf des Klassenmoduls des Formulars (die fortgeschrittene Version finden Sie im Formular frmNotizenMitDetailformular<\/b>):<\/p>\n Da nun einige Zusatzaufgaben zu erledigen sind, haben wir die Prozedur DatenAnzeigen <\/b>stark angepasst (s. Listing 4). Die Prozedur deklariert weitgehend die gleichen Variablen, einige fallen aber weg. Dann initialisiert sie das Collection<\/b>-Objekt colObjects<\/b>, welches alle Wrapperklassen für die Zellen und Icons der Tabelle aufnehmen soll. Die Definition der Tabellenzeile mit den Spaltenüberschriften erfolgt wieder wie in der vorherigen Version. Innerhalb der Do While<\/b>-Schleife zum Durchlaufen der Datensätze der Tabelle tblNotizen <\/b>ermittelt die Prozedur weiterhin die Hintergrund- und Rahmenfarben für die einzelnen Zeilen. Dann legt sie das HTMLTableRow<\/b>-Objekt an und fügt das erste HTMLTableCell<\/b>-Objekt ein. Die FormatCell<\/b>-Methode haben wir hier etwas erweitert, denn wir übergeben dieser mit dem letzten Parameter auch gleich den anzuzeigenden Text, der dann in der Eigenschaft InnerText <\/b>landen soll. Nun folgt ein wichtiger Schritt: Wir rufen die Routine CreateCellWrapper <\/b>auf, die wie in Listing 5 aussieht, und übergeben dieser den Verweis auf das soeben erstellte HTMLTableCell<\/b>-Objekt objCell<\/b>.<\/p>\n Listing 4: Die Funktion CreateCellWrapper<\/span><\/b><\/p>\n Die Routine CreateCellWrapper <\/b>erstellt ein neues Objekte auf Basis der Klasse clsCellWrapper <\/b>und weist diesem Werte für die Eigenschaften Cell<\/b>, ID <\/b>und Form <\/b>zu. Cell <\/b>enthält den Verweis auf das HTMLTableCell<\/b>-Objekt, das wir mit dem Ereignis OnDblClick <\/b>ausstatten wollen.<\/p>\n ID <\/b>ist der Primärschlüsselwert des Datensatzes und Form <\/b>enthält einen Verweis auf das Formular, welches das Web-browser<\/b>-Steuerelement anzeigt (übergeben mit Me<\/b>).<\/p>\n Das Objekt des Typs clsCellWrapper <\/b>wird dann an die aufrufende Zeile zurückgegeben. Dort wird es direkt weiterverarbeitet, indem es mit der Add<\/b>-Methode zur Collection colObjects <\/b>hinzugefügt wird (da wir das Wrapper-Objekt sonst im Code nicht mehr benötigen, brauchen wir es erst gar nicht mit einer Objektvariablen zu referenzieren). Die Klasse clsCellWrapper <\/b>beschreiben wir weiter unten.<\/p>\n Auf die gleiche Weise geht die Prozedur einen Schritt weiter mit der Zelle zur Anzeige des Inhalts des Feldes Notiz vor.<\/p>\n Nun folgen die hinteren beiden Zellen je Zeile, die wir im vorherigen Beispiel noch nicht berücksichtigt haben. Diese sollen die Schaltflächen beziehungsweise Icons zum Starten des Bearbeitungsvorgangs eines Datensatzes beziehungsweise zum Löschen eines Datensatzes einleiten.<\/p>\n Dazu erstellt die Prozedur DatenAnzeigen <\/b>zunächst wieder ein HTMLTableCell<\/b>-Objekt. Dieses formatiert sie mit der Routine FormatCell<\/b>, die Sie ja bereits weiter oben kennen gelernt haben. Nun fügen wir das HTMLImg<\/b>-Element zu der in objCell <\/b>gespeicherten Tabellenzelle hinzu. Dazu ruft die Prozedur die Funktion AddImage<\/b> aus Listing 6 auf. Diese erwartet einen Verweis auf das HTMLDocument<\/b>-Objekt, auf das übergeordnete Element (hier das HTMLTableCell<\/b>-Element), den Pfad zur anzuzeigenden Bilddatei sowie die Breite und die Höhe der Bilddatei.<\/p>\n Listing 6: Die Funktion AddImage<\/span><\/b><\/p>\n Die Funktion AddImages <\/b>erstellt mit der createElement<\/b>-Methode ein neues Element des Typs HTMLImg <\/b>und speichert den Verweis darauf in der Variablen obj-Image<\/b>. Dann hängt sie dieses mit der Append<\/b>-Methode an das übergeordnete Element an, also das HTMLTableCell<\/b>-Element aus objCell<\/b>. Die Eigenschaft src <\/b>nimmt den Pfad zur anzuzeigenden Bilddatei auf (in unserem Fall im Verzeichnis der Datenbank befindlich), die Eigenschaften Width <\/b>und Height <\/b>die Abmessungen. Schließlich weist sie das neue Objekt objImage <\/b>dem Rückgabewert der Funktion, AddImage<\/b>, zu.<\/p>\n Damit geht es weiter in der Prozedur DatenAnzeigen<\/b>. Hier landet das Ergebnis der Funktion AddImage <\/b>in der Variablen objImage<\/b>. Dieses übergibt die Prozedur gleich der Funktion CreateImageWrapper <\/b>aus Listing 7. Diese erwartet den Verweis auf das HTMLImg<\/b>-Objekt aus objImage<\/b>, den Primärschlüsselwert des aktuellen Datensatzes, einen String, der die auszuführende Aktion definiert (zum Beispiel edit <\/b>oder delete<\/b>) sowie einen Verweis auf das übergeordnete Form<\/b>-Objekt.<\/p>\n![\"Zusätzlicher](\"..\/fileadmin\/_temp_\/2016_02\/pic_1029_002.png\")
<\/p>\n![\"Beispieldaten](\"..\/fileadmin\/_temp_\/2016_02\/pic_1029_003.png\")
<\/p>\nProgrammierung des Webbrowser-Steuerelements<\/h2>\n
Private <\/span>WithEvents objWebbrowser As <\/span>WebBrowser\r\nPrivate <\/span>WithEvents objDocument As <\/span>MSHTML.HTMLDocument<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objWebbrowser = Me!ctlWebbrowser.Object\r\n WebbrowserLeeren\r\n objWebbrowser.Document.Write \"<p><\/p>\"\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>WebbrowserLeeren()\r\n objWebbrowser.Navigate \"about:blank\"\r\n Do While<\/span> Not<\/span> objWebbrowser.ReadyState = READYSTATE_COMPLETE\r\n DoEvents\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nDaten im Webbrowser-Steuerelement anzeigen<\/h2>\n
![\"Anzeige](\"..\/fileadmin\/_temp_\/2016_02\/pic_1029_004.png\")
<\/p>\nPrivate Sub <\/span>Form_Current()\r\n DatenAnzeigen\r\n Debug.Print<\/span> objDocument.documentElement.innerHTML\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>DatenAnzeigen()\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>strBackgroundColor As String<\/span>\r\n Dim <\/span>strBorderColor As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> objWebbrowser = Me!ctlWebbrowser.Object\r\n Set<\/span> objDocument = objWebbrowser.Document\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblNotizen\", dbOpenDynaset)\r\n WebbrowserLeeren\r\n objWebbrowser.Document.Clear\r\n Set<\/span> objTable = objDocument.createElement(\"Table\")\r\n objDocument.Body.appendChild objTable\r\n objTable.Style.borderCollapse = \"collapse\"\r\n Set<\/span> objRow = objTable.insertRow\r\n Set<\/span> objCell = objRow.insertCell\r\n With<\/span> objCell\r\n FormatHeader objCell\r\n .innerText = \"Datum:\"\r\n End With<\/span>\r\n Set<\/span> objCell = objRow.insertCell\r\n With<\/span> objCell\r\n FormatHeader objCell\r\n .innerText = \"Notiz:\"\r\n End With<\/span>\r\n Do While<\/span> Not<\/span> rst.EOF\r\n If <\/span>rst.AbsolutePosition Mod<\/span> 2 = 0 Then<\/span>\r\n strBackgroundColor = \"#FFFFFF\"\r\n strBorderColor = \"#EEEEEE\"\r\n Else<\/span>\r\n strBackgroundColor = \"EEEEEE\"\r\n strBorderColor = \"#FFFFFF\"\r\n End If<\/span>\r\n Set<\/span> objRow = objTable.insertRow\r\n Set<\/span> objCell = objRow.insertCell\r\n With<\/span> objCell\r\n FormatCell objCell, strBackgroundColor, strBorderColor\r\n .ID = rst!NotizID\r\n .innerText = rst!AngelegtAm\r\n End With<\/span>\r\n Set<\/span> objCell = objRow.insertCell\r\n With<\/span> objCell\r\n FormatCell objCell, strBackgroundColor, strBorderColor\r\n .ID = rst!NotizID\r\n .innerText = rst!Notiz\r\n End With<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\n<HEAD><\/HEAD>\r\n<BODY>\r\n <TABLE><\/TABLE>\r\n<\/BODY><\/pre>\n
Private Sub <\/span>FormatHeader(objCell As <\/span>HTMLTableCell)\r\n With<\/span> objCell.Style\r\n .BorderColor = \"#999999\"\r\n .BackgroundColor = \"#CCCCCC\"\r\n .BorderWidth = \"1px\"\r\n .BorderStyle = \"solid\"\r\n .TextAlign = \"center\"\r\n .VerticalAlign = \"top\"\r\n .FontSize = \"9pt\"\r\n .FontFamily = \"Calibri\"\r\n .FontWeight = \"bold\"\r\n .Padding = \"5,5,5,5\"\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>FormatCell(objCell As <\/span>HTMLTableCell, Optional<\/span> strBackgroundColor _\r\n As String<\/span>, Optional<\/span> strBorderColor As String<\/span>)\r\n With<\/span> objCell.Style\r\n If <\/span>Len<\/span>(strBackgroundColor) > 0 Then<\/span>\r\n .backgroundColor = strBackgroundColor\r\n Else<\/span>\r\n .backgroundColor = \"#FFFFFF\"\r\n End If<\/span>\r\n If <\/span>Len<\/span>(strBorderColor) > 0 Then<\/span>\r\n .BorderColor = strBorderColor\r\n Else<\/span>\r\n .BorderColor = \"#CCCCCC\"\r\n End If<\/span>\r\n .BorderWidth = \"1px\"\r\n .BorderStyle = \"solid\"\r\n .TextAlign = \"left\"\r\n .FontSize = \"9pt\"\r\n .verticalAlign = \"top\"\r\n .fontFamily = \"Calibri\"\r\n .padding = \"5,5,5,5\"\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nAuf die Taste F5 reagieren<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2016_02\/pic_1029_005.png\")
<\/p>\nPrivate Sub <\/span>objDocument_onkeydown()\r\n Dim <\/span>Cancel As Boolean<\/span>\r\n Cancel = False<\/span>\r\n With<\/span> objDocument.parentWindow.event\r\n If <\/span>.keyCode = 116 Then<\/span>\r\n Cancel = True<\/span> ''F5\r\n End If<\/span>\r\n If <\/span>Cancel Then<\/span>\r\n DatenAnzeigen\r\n End If<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n<HEAD><\/HEAD>\r\n<BODY>\r\n <TABLE style=\"BORDER-COLLAPSE: collapse\">\r\n <TBODY>\r\n <TR>\r\n <TD style=\"BORDER-BOTTOM: #999999 1px solid; TEXT-ALIGN: center; BORDER-LEFT: #999999 1px solid; \r\n PADDING-BOTTOM: 5px; BACKGROUND-COLOR: #cccccc; PADDING-LEFT: 5px; PADDING-RIGHT: 5px; \r\n FONT-FAMILY: Calibri; FONT-SIZE: 9pt; VERTICAL-ALIGN: top; BORDER-TOP: #999999 1px solid; \r\n FONT-WEIGHT: bold; BORDER-RIGHT: #999999 1px solid; PADDING-TOP: 5px\">Datum:<\/TD>\r\n <TD style=\"...\" id=1>Notiz:<\/TD>\r\n <\/TR>\r\n <TR>\r\n <TD style=\"...\" id=1>01.03.2016<\/TD>\r\n <TD style=\"...\" id=1>Dies ist eine kurze Notiz.<\/TD><\/TR>\r\n <TR>\r\n <TD style=\"...\" id=2>02.03.2016<\/TD>\r\n <TD style=\"...\" id=2>Dies ist eine lange Notiz. Dies ist eine lange Notiz. ... Dies ist eine lange Notiz. <\/TD>\r\n <\/TR>\r\n <TR>\r\n <TD style=\"...\" id=3>02.03.2016<\/TD>\r\n <TD style=\"...\" id=3>Dies ist eine kurze Notiz.<\/TD>\r\n <\/TR>\r\n <TR>\r\n <TD style=\"...\" id=4 >02.03.2016<\/TD>\r\n <TD style=\"...\" id=4>Dies ist eine lange Notiz. Dies ist eine lange Notiz. ... Dies ist eine lange Notiz. <\/TD>\r\n <\/TR>\r\n <TR>\r\n <TD style=\"...\" id=5 >02.03.2016<\/TD>\r\n <TD style=\"...\" id=5>Dies ist eine kurze Notiz.<\/TD>\r\n <\/TR>\r\n <TR>\r\n <TD style=\"...\" id=6 >06.03.2016<\/TD>\r\n <TD style=\"...\" id=6>Dies ist eine lange Notiz. Dies ist eine lange Notiz. ... Dies ist eine lange Notiz. <\/TD>\r\n <\/TR>\r\n <\/TBODY>\r\n <\/TABLE>\r\n<\/BODY><\/pre>\n
Erweiterung: Anzeigen eines Detailformulars<\/h2>\n
HTML-Ansicht mit Aktion füllen<\/h2>\n
![\"Anzeigen](\"..\/fileadmin\/_temp_\/2016_02\/pic_1029_006.png\")
<\/p>\nDim <\/span>colObjects As <\/span>Collection<\/pre>\nPrivate Function <\/span>CreateCellWrapper(objCell As <\/span>HTMLTableCell, _\r\n varID As Variant<\/span>, frm As <\/span>Form)\r\n Dim <\/span>objCellWrapper As <\/span>clsCellWrapper\r\n Set<\/span> objCellWrapper = New<\/span> clsCellWrapper\r\n With<\/span> objCellWrapper\r\n Set<\/span> .Cell = objCell\r\n .ID = varID\r\n Set<\/span> .Form = frm\r\n End With<\/span>\r\n Set<\/span> CreateCellWrapper = objCellWrapper\r\nEnd Function<\/span><\/pre>\nIcons zum Löschen und Bearbeiten hinzufügen<\/h2>\n
Private Function <\/span>AddImage(objDocument As <\/span>HTMLDocument, objParent As Object<\/span>, _\r\n strImage As String<\/span>, lngWidth As Long<\/span>, lngHeight As Long<\/span>) As <\/span>HTMLImg\r\n Dim <\/span>objImage As <\/span>HTMLImg\r\n Set<\/span> objImage = objDocument.createElement(\"img\")\r\n objParent.appendChild objImage\r\n objImage.src = strImage\r\n objImage.Width = lngWidth\r\n objImage.Height = lngHeight\r\n Set<\/span> AddImage = objImage\r\nEnd Function<\/span><\/pre>\nPrivate Function <\/span>CreateImageWrapper(objImage As <\/span>HTMLImg, _\r\n varID