<\/p>\n
Eine Access-Textbox, in einem Formular an ein Memo-Feld gebunden, ist eine spröde Angelegenheit, wenn es darum geht, ihren Inhalt ansprechend zu gestalten. Denn alle Formatierungsmöglichkeiten beziehen sich immer nur auf das ganze Feld, den gesamten Text. Ein einzelnes Wort etwa fett hervorzuheben, ist nicht möglich. Erst mit Access 2007 kam Farbe ins Spiel und der Richtext-Modus für Textfelder hielt Einzug, über den man Texte rudimentär formatieren kann. In allen früheren Access-Versionen bleibt man für diesen Zweck jedoch auf Fremdsteuerelemente angewiesen.<\/b><\/p>\n
Die Anforderung, Texte zu formatieren, stellt sich auch in Datenbanken oft. Es müssen nicht gleich komplette Dokumente sein, die mit einem Datensatz verknüpft sind – es reichen bereits die berüchtigten Notiz- und Anmerkungsfelder, die man gern für Zusatzinformationen in Formulare einbaut, damit der Anwender dort alles unterbringen kann, was nicht in das Raster der vorgegebenen Eingabefelder passt.<\/p>\n
Von dieser Möglichkeit wird dann erfahrungsgemäß auch reichlich Gebrauch gemacht, was nicht selten zu unübersichtlichen Textwüsten führt. Dabei würde nur wenig Formatierung bereits ausreichen, um eine gegliederte Darstellung des Textes zu ermöglichen.<\/p>\n
In der Regel kommt ein Richtext-ActiveX-Steuerelement (richtx32.ocx<\/b>) zum Einsatz, um dem Mangel abzuhelfen. Abgesehen davon jedoch, dass der Entwickler dann noch viel Arbeit vor sich hat, um das Steuerelement zusätzlich etwa mit einer Symbolleiste auszustatten, die es dem Anwender ermöglicht, den Text komfortabel zu editieren, kommen hier mindestens zwei Probleme ins Spiel.<\/p>\n
Einmal ist das entsprechende OCX von Microsoft eigentlich nicht frei erhältlich, sondern entweder mit der Developer Edition von Access gebundelt, oder mit verschiedenen Entwicklungsumgebungen, wie Visual Basic 6.<\/p>\n
Allerdings gibt es auch freie Alternativen, wie etwa das Steuerelement von Stephen Lebans oder das von vbAccelerator [1]. Zweitens muss man solch ein OCX mit der Datenbank weitergeben und ruft im Zweifelsfall Scherereien mit seiner Registrierung und den Verweisen im VBA-Projekt hervor.<\/p>\n
Microsoft wurde sich dieser Unzulänglichkeit zum Formatieren offenbar bewusst und stellte mit Access 2007 den sogenannten Richtext-Modus für Textboxen bereit.<\/p>\n
Unter der Voraussetzung, dass ein Memofeld einer Tabelle als Datenherkunft des Steuerelements dient, das seinerseits bereits in den Richtext-Modus versetzt wurde, kann in einer beliebigen Textbox der Inhalt über eine Popup-Toolbar formatiert werden (siehe Bild 1). <\/p>\n
![\"A2007_toolbar.png\"](\"..\/fileadmin\/_temp_\/2010_01\/Webbrowser-web-images\/A2007_toolbar_opt.jpeg\")
<\/p>\n
Bild 1: Textformatierung in Access 2007 (Richtext) über Popup-Toolbar<\/span><\/b><\/p>\n Leider ist dieses Popup-Menü, das nur beim Markieren von Text erscheint, auch schon die einzige Möglichkeit, auf die Formatierung des Textes Einfluss zu nehmen, und seine Bedienung erfordert etwas Geschicklichkeit im Umgang mit der Maus. Eine programmgesteuerte Einflussnahme ist nicht gegeben und das Menü lässt sich auch nicht abschalten.<\/p>\n Intern wird die Formatierung dann über HTML-Tags gespeichert, weshalb die Bezeichnung Richtext irreführend ist. Theoretisch ist es möglich, diese HTML-Tags anschließend über VBA-Code zu verändern.<\/p>\n Indessen darf man allerdings nicht erwarten, dass im Richtext-Modus nun beliebige HTML-Auszeichnungen genauso angezeigt würden, wie in einem Webbrowser; die Access 2007-Textbox beherrscht tatsächlich nur jene, die sich auch über das Popup-Menü erzeugen lassen.<\/p>\n Genügend Gründe also, sich nicht nur für die Versionen vor Access 2007 Gedanken über alternative Lösungen zu machen …<\/p>\n Webbrowser-Steuerelement<\/b><\/p>\n Das Microsoft Webbrowser Control<\/b>, welches Sie über die Liste der ActiveX-Steuerelemente in ein Formular einfügen können, stellt einen Mini-Browser für HTML-Dokumente bereit. Im kommenden Access 2010 wird ein solches Steuerelement übrigens standardmäßig zur Bordausstattung von Access gehören.<\/p>\n Es hat dort den Vorteil, sich direkt an ein Memofeld einer Tabelle binden zu lassen, was mit dem normalen Webbrowser-ActiveX zwar nicht möglich ist, uns andererseits aber, wie später noch ausgeführt wird, nicht gerade vor weltbewegende Programmierprobleme stellt.<\/p>\n Das Webbrowser-Steuerelement hat den entscheidenden Vorteil, dass es grundsätzlich auf jedem Windows-System vorhanden ist und mit der Installation von Access oder Office gar nichts zu tun hat. Der Internet-Explorer selbst stellt es zur Verfügung. Verweis- oder Registrierungsprobleme gibt es hier nicht.<\/p>\n Das Steuerelement ist tatsächlich identisch mit dem Anzeigebereich des Internet-Explorers und lässt sich daher auch auf gleiche Weise über dessen Objektmodell MSHTML<\/b>, auch DOM<\/b> genannt, steuern.<\/p>\n Dieses Document Object Model <\/b>ist enorm umfangreich und leistungsfähig. Entwickler, die auch Webseiten mit Javascript erstellen, werden das wissen. Man kann auf jegliches Element eines HTML-Dokumentes sowohl zugreifen und dessen Eigenschaften ändern oder Aktionen darauf ausführen, wie auch neue Elemente erzeugen.<\/p>\n Stellen wir also fest, dass mit dem Webbrowser Control ein geeignetes und unkompliziertes Steuerelement bereitsteht, mit dem durchformatierter Text angezeigt werden kann.<\/p>\n Wie aber können wir den in diesem Steuerelement angezeigten Text editieren – der Internet Explorer bietet ja selbst auch keine Möglichkeit für manuelle änderungen<\/p>\n Webbrowser im Design-Mode<\/b><\/p>\n Die Tatsache, dass sich der Internet-Explorer mit nur einer Codezeile in einen Modus versetzen lässt, der das Dokument bearbeitbar macht, ist nur wenig bekannt.<\/p>\n Dabei kann Text nicht nur gelöscht oder hinzugefügt, sondern es können auch ohne viel Aufwand Formatierungen verändert werden. Der „echte“ Internet-Explorer birgt aber natürlich keine Steuer- oder Menüelemente, über die sich das realisieren ließe. Mit wenigen Zeilen VBA erwecken wir jedoch das Webbrowser-Steuerelement unter Access zum Leben, wie die folgende Anleitung zeigt:<\/p>\n Nach dem Öffnen des Formulars zeigt dieses die gewünschte Webseite an. Die Navigate2<\/b>-Methode ist dafür verantwortlich und erledigt das Gleiche, wie die Eingabe einer URL in die Adresszeile des Internet-Browsers.<\/p>\n Unser Ziel ist es jedoch nicht, eine x-beliebige Webseite anzuzeigen, sondern neue HTML-Dokumente zu erzeugen und mit HTML-Strings aus einem Tabellenfeld zu speisen. Um ein solches neues Dokument im Steuerelement aufzubauen, reicht diese einfache Anweisung:<\/p>\n Diese Zeile ist unbedingt erforderlich, denn ohne sie zeigt das Steuerelement schlicht eine weiße Fläche an. Erst ein Rechtsklick zur Laufzeit offenbart den Unterschied: Mit about:blank <\/b>gibt es ein Kontextmenü, ohne gibt es keines.<\/p>\n Wählen Sie im Kontextmenü dann den Eintrag Quelltext anzeigen<\/b>, tritt dieser Inhalt zutage: <HTML><\/HTML><\/b> und manchmal auch <BODY><\/BODY><\/b>.<\/p>\n Jetzt wird es interessant. Wie kann man das neue HTML-Dokument mit weiterem Inhalt, etwa aus einer Tabelle, füllen<\/p>\n Auch das lässt sich erstaunlich einfach realisieren: Man schreibt den HTML-Text über die write<\/b>-Methode des Dokuments. Zuvor aber noch ein kurzer Ausflug in das DOM-Modell.<\/p>\n DOM und MSHTML<\/b><\/p>\n Auf das Webbrowser-Steuerelement selbst haben Sie, wie oben angeführt, über dessen Object<\/b>-Eigenschaft Zugriff.<\/p>\n Öffnen Sie im VBA-Editor den Objektkatalog, so finden Sie dort unter der Bibliothek SHDocVw<\/b>, auf welche automatisch beim Einfügen eines Webbrowser-Controls verwiesen wird, das Klassenmodell zum Steuerelement. Die Klasse, die dem Control entspricht, nennt sich hier Webbrowser<\/b>.<\/p>\n Sie zeigt allerlei Eigenschaften und Methoden, mit denen sich etwa die Gestalt des Steuerelements selbst einstellen lässt – unter anderem die bereits erwähnte Navigate2<\/b>-Methode. Augenscheinlich findet sich jedoch nichts, was einen direkten Bezug zum HTML-Inhalt des gehosteten Dokuments hätte.<\/p>\n Die Bibliothek enthält derlei tatsächlich nicht. Dafür ist eine andere Bibliothek zuständig, die Sie manuell in die Verweise aufnehmen sollten und die ebenfalls vom Internet-Explorer-System bereitgestellt wird: MSHTML<\/b>.<\/p>\n Öffnen Sie die Liste der Verweise (VBA-Editor, Menü Extras|Verweise…<\/b>) und aktivieren Sie die Bibliothek Microsoft HTML Object Library<\/b>.<\/p>\n Wenn Sie sich diese Bibliothek im Objektkatalog zu Gemüte führen, dann steht vermutlich die Frage im Raum, wie deren erschlagender Umfang von Klassen zu bändigen sei und wie die Verbindung zwischen dem Webbrowser-Control und der MSHTML<\/b>-Bibliothek zustande kommt.<\/p>\n Das geschieht über genau eine Eigenschaft des Web-Controls, nämlich Document<\/b>. Diese gibt ein Objekt der MSHTML<\/b>-Klasse HTMLDocument <\/b>zurück, welche im Grunde die oberste Ebene des DOM<\/b>-Modells darstellt. Ein HTMLDocument <\/b>enthält dann zahlreiche Unterobjekte, die ihrerseits haufenweise Eigenschaften und Auflistungen beheimaten. Nur ein exemplarisches Beispiel:<\/p>\n Das HTMLDocument <\/b>enthält eine body<\/b>-Eigenschaft, welche ein HTMLBody<\/b>-Objekt zurückgibt. Das HTMLBody<\/b>-Objekt kennt eine style<\/b>-Eigenschaft in Form der HTMLStyle<\/b>-Klasse. HTMLStyle <\/b>wiederum zeigt eine Eigenschaft fontSize<\/b>, die die Schriftgröße einstellt oder zurückgibt.<\/p>\n Wollten wir also die Schriftgröße des gesamten Bodys eines im Webcontrol geladenen Dokuments auf 11pt <\/b>setzen, so ließe sich das auch ohne MSHTML <\/b>über folgenden Ausdruck erledigen:<\/p>\n Hier wird deutlich, dass der Verzicht auf die MSHTML<\/b>-Bibliothek zu sehr langen Ausdrücken und zur Unübersichtlichkeit führt.<\/p>\n Einfacher ist es, wenn man das Dokument direkt einer Objektvariablen zuweist und dann alle weiteren Aktionen mit deren Hilfe ausführt:<\/p>\n Dies soll lediglich verdeutlichen, wie verschachtelt das DOM<\/b>-Modell ist und wie man mithilfe von Objektvariablen mehr Struktur in den Code bringen kann.<\/p>\n Völlig unverzichtbar wird MSHTML<\/b>, wenn man auf Ereignisse reagieren will. Ein Objekt des Typs HTMLDocument <\/b>etwa kann fast 40 Ereignisse auslösen.<\/p>\n Markiert man beispielsweise im angezeigten Dokument eine Passage, so löst dies ein Ereignis onselectionchange <\/b>aus. Um auf dieses reagieren zu können, benötigt man eine Objektvariable mit dem Zusatz WithEvents<\/b>:<\/p>\n Die komplette Referenz zu DOM<\/b> und MSHTML <\/b>finden Sie unter [3] im Internet. An dieser Stelle soll es bei den wenigen grundsätzlichen Anregungen zur Arbeit mit der Bibliothek bleiben. Notiz am Rande: Die MSHTML<\/b>-Bibliothek erweitert sich ständig im selbem Maße wie der Internet-Explorer.<\/p>\n Deshalb finden sich in der aktuellen Version etwa auch Klassen zum Phishing darin. Das gibt es aber erst seit Version 7. Wenn Sie mit der Bibliothek arbeiten, sollten Sie folglich genau darauf achten, dass keine Methoden Anwendung finden, die es auf einem etwaigen Zielsystem noch gar nicht gibt, weil dort vielleicht noch der Internet Explorer 6 installiert ist.<\/p>\n In der Referenz zu MSHTML <\/b>ist jeweils angegeben, seit welcher Version eine Methode gültig ist.<\/p>\n HTML-Dokument bearbeiten<\/b><\/p>\n Kommen wir zur ursprünglichen Aufgabe zurück, ein Dokument im Web-Control in den bearbeitbaren Zustand zu versetzen.<\/p>\n Bisher sehen Sie nach dem Laden eines Dokuments über about:blank <\/b>ja nur eine leere Fläche. Mit einer weiteren Zeile schreiben Sie nun HTML-Code hinein:<\/p>\n Und schon erscheint die Ausgabe TEST<\/b> im Steuerelement. Falls Sie hier auf die Idee kommen sollten, wie oben angeregt, eine Objektvariable einzusetzen, werden Sie keinen Erfolg haben:<\/p>\n Dies führt zu einem Fehler, weil ausgerechnet die write<\/b>-Methode von MSHTML.HTMLDocument <\/b>nicht VBA-komform ist und als Parameter einen Variant<\/b>-Typ vorsieht, den es unter VBA im Unterschied zu C++ nicht gibt.<\/p>\n Die Document.write<\/b>-Methode – siehe oben – des Controls selbst hat damit aber offenbar keine Probleme und führt intern die notwendige Konvertierung durch.<\/p>\n Der hier hartkodierte Inhalt des Dokuments aus einer String<\/b>-Variablen lässt sich selbstverständlich genauso gut aus einem Tabellenfeld auslesen, das wegen der möglichen Länge des Inhalts als Memofeld deklariert sein sollte. Im Formular könnte das mit nur einer Zeile so aussehen:<\/p>\n <\/p>\n Der Clou: Mit ebenfalls nur einer Zeile lässt sich das Dokument editierbar machen:<\/p>\n Nach dieser Anweisung können Sie den Cursor nun an eine beliebige Stelle im Dokument setzen und Text dazu schreiben oder löschen – gerade so, wie in einem Texteditor.<\/p>\n Den Inhalt des geänderten Dokuments lesen Sie anschließend aus dem Control aus und können ihn wieder im Datensatz speichern:<\/p>\n Hier wird nur der Body des Dokuments ausgelesen, aber mehr benötigen Sie auch nicht, weil das <HTML><\/b>-Tag ja bereits von einem neu per about:blank <\/b>erzeugten Dokument angelegt wird. outerHTML <\/b>bedeutet dabei, dass der HTML-Code inklusive des body<\/b>-Tags und möglicher Attribute selbst zurückgegeben wird, während etwa innerHTML <\/b>nur den eigentlichen Inhalt des Bodys enthielte.<\/p>\n Möchten Sie das Dokument schließlich wieder in den normalen Zustand versetzen, so schalten Sie den Design-Mode einfach wieder ab:<\/p>\n Wichtige Anmerkung dazu: Sollten Sie das Dokument einer Objektvariablen zugewiesen haben, so ist diese nach dem ändern des Design-Modes in der Regel nicht mehr gültig. Sie sollten deshalb nach jedem Wechsel des Design-Modes die Zuweisung erneut vornehmen.<\/p>\n HTML-Dokument formatieren<\/b><\/p>\n Mit dem bisher Beschriebenen sind Sie in der Lage, im HTML-Dokument des Steuerelements Text hinzuzufügen oder zu löschen. Was nun noch fehlt ist die Möglichkeit, ihn zu formatieren. <\/p>\n Dazu ist es für die wichtigsten Funktionen gar nicht notwendig, die HTML-Auszeichnungen per Code zu modifizieren. Normalerweise muss ja ein Text mit Formatierungs-Tags versehen werden, damit er sich in veränderter Gestalt präsentiert.<\/p>\n So braucht es etwa das Tag <em><\/b>, um ein Wort fett wiederzugeben: <em>TEST<\/em><\/b>. Diese Tags muss man jedoch nicht in den HTML-Code hineinflicken, sondern bedient sich einer komfortablen Methode von MSHTML<\/b>, die das automatisch macht, nämlich der Anweisung execCommand<\/b>.<\/p>\n Diese Methode eines HTMLDocument<\/b>-Objekts erwartet in der Regel lediglich einen Anweisungs-String als Parameter und wirkt sich dann auf die aktuelle Auswahl im Dokument aus. Um eine mit der Maus markierte Passage fett zu formatieren, setzen Sie diese Anweisung ab:<\/p>\n Manchmal wird auch ein zusätzlicher Parameter benötigt, der neben der Formatierungsanweisung noch einen Wert übergibt, wie etwa beim ändern der Schriftart:<\/p>\n Damit können Sie nun beispielsweise eine Schaltfläche mit der Aufschrift Fett <\/b>versehen und in deren Click<\/b>-Ereignisprozedur die Anweisung von oben schreiben. Sie erhalten somit einen einfachen WYSIWYG-HTML-Editor.<\/p>\n Eine gute Demo für einen solchen auf der execCommand<\/b>-Methode beruhenden Editor unter Access finden Sie bei Stephen Lebans [2].<\/p>\n Wenn Sie erfahrem möchten, welche Kommandos die execCommand<\/b>-Methode unterstützt und wie die genaue Syntax auszusehen hat, so finden Sie eine erschöpfende Zusammenstellung unter [4].<\/p>\n Nicht für jeden Zweck allerdings reicht diese Methode allein aus und der HTML-Code muss manchmal direkt modifiziert werden. Auch hier gibt es jedoch Unterstützung durch MSHTML <\/b>in Gestalt der Anweisung pasteHTML<\/b>.<\/p>\n Sie ersetzt den augenblicklich markierten Text durch einen im Parameter übergebenen HTML-Code. Das könnte etwa so aussehen:<\/p>\n Hier wird zunächst die aktuelle Auswahl im Dokument als selection<\/b>-Objekt erhalten. Mit diesem selbst kann man aber noch nicht viel anfangen. Seine Funktion createRange <\/b>erst gibt das markierte Element oder eine ganze Auflistung von Elementen zurück.<\/p>\n In der Regel wird das ein Objekt der MSHTML<\/b>-Klasse IHTMLTxtRange <\/b>sein. Und eben diese kennt die Methode pasteHTML<\/b>, die genau dasselbe tut, als würden Sie HTML-Code aus der Zwischenablage ins Dokument einfügen. Die aktuelle Auswahl wird also durch den neuen HTML-Code ersetzt. Ist kein Text ausgewählt, so wird der HTML-String an jener Stelle eingefügt, an der sich der Cursor befindet.<\/p>\n Nun möchten Sie allerdings weniger einen komplett neuen HTML-Code einfügen, als vielmehr vorhandenen Text mit Formatierungs-Tags „umrahmen“. Dazu muss im ersten Schritt der ausgewählte Text erhalten werden, was ebenfalls über das selection<\/b>-Objekt möglich ist:<\/p>\n Nun kann der Text mit den gewünschten Formatierungs-Tags zusammengesetzt werden:<\/p>\n Dieses Beispiel ist an sich überflüssig, da ja bereits die execCommand<\/b>-Methode mit dem Parameter Bold<\/b> zum gleichen Ergebnis führt. Es demonstriert aber die grundsätzliche Vorgehensweise auch für kompliziertere Operationen.<\/p>\n Sie möchten eventuell erfahren, wie ein im Dokument markiertes Wort formatiert ist<\/p>\n Auch dazu reicht ein einzige Funktion aus, nämlich die queryCommandValue<\/b>-Methode des selection<\/b>-Objekts:<\/p>\n Hier wird abgefragt, ob die Auswahl fett formatiert ist. Der Ausdruck gibt True <\/b>zurück, wenn das der Fall ist. Eine Rückgabe aller Formatierungen im Form eines Arrays oder einer Collection ist allerdings nicht möglich – es muss schon nach jeder möglichen Formatierung einzeln gefragt werden.<\/p>\n Die Rückgabe ist vom Datentyp Variant <\/b>und kann je nach Kommando ein Bool-, Integer- oder String-Typ sein.<\/p>\n Nützlich ist das etwa, wenn Sie die Formatierung über den Zustand eines Formatierungs-Buttons signalisieren möchten. Die erwähnte Schaltfläche Fett <\/b>könnte etwa als Umschaltfläche daher kommen und bei fett markiertem Text in gedrücktem Zustand erscheinen, so wie das auch in Textverarbeitungen geschieht.<\/p>\n Damit Ihre Anwendung erkennt, wann sich die aktuelle Markierung geändert hat und somit die Liste der Formatierungen erneut abgefragt werden muss, machen Sie sich das onselectionchange<\/b>-Ereignis des HTMLDocument<\/b>-Objekts zunutze. In dieser Ereignisprozedur ermitteln Sie einfach alle vorgesehenen Formatierungen und stellen den Zustand der Schaltflächen entsprechend ein.<\/p>\n Aber damit wären wir eigentlich schon bei der Beschreibung der Beispieldatenbank zu diesem Beitrag, die sich htmlform.mdb<\/b> nennt und unter Access 2000 und höher lauffähig ist.<\/p>\n Datengebundenes HTML-Steuerelement<\/b><\/p>\n In Bild 2 sehen Sie das Beispielformular der Anwendung htmlform.mdb<\/b>, welches eine ziemlich einfache Adresskartei darstellt, gebunden an die Tabelle tblPersonen<\/b>. <\/p>\n Bild 2: Formular der Beispieldatenbank mit formatierbarem Anmerkungenfeld<\/span><\/b><\/p>\n Neben den gängigen Datenfeldern ist ein Anmerkungen-Feld enthalten, dessen Inhalt sich wie in einer Textverarbeitung formatieren lässt – das Webbrowser-Steuerelement wird dafür verwendet.<\/p>\n Damit die Lösung allgemein verwendbar ist, kommt für dieses Feld ein Unterformular zum Einsatz, das auch den ganzen benötigten VBA-Code einhält. Sie können dieses Unterformular (sfrmHTML<\/b>) auch in Ihre eigenen Anwendungen integrieren.<\/p>\n Was Sie dann noch mitimportieren müssen, ist das Modul mdl_sfrmHTML<\/b>, welches einige Hilfsroutinen enthält, die leider nicht direkt in den Formular-Code aufgenommen werden könnten, weil API-Callbacks zur Enumeration der Schriftarten im System zum Einsatz kommen, die den Operator AddressOf <\/b>erforderlich machen. Dieser Operator lässt sich nicht für Prozeduren in Klassenmodulen verwenden.<\/p>\n Daneben müssen in der Zielanwendung noch Verweise auf die MSHTML<\/b>-Bibliothek sowie auf SHDocVw<\/b> gesetzt sein. Diese Bibliothek finden Sie in der Liste der Verweise unter Microsoft Internet Controls<\/b>; sie wird auch automatisch beim Einfügen eines Webbrowser Controls <\/b>gesetzt.<\/p>\n Das Unterformular lässt sich dann wie ein eigenes Steuerelement einsetzen und an ein Datenfeld des Hauptformulars binden. Lediglich einige Eigenschaften des Unterformulars müssen eingestellt werden, alles Weitere läuft voll automatisch ab – später mehr dazu.<\/p>\n Im Rohzustand, aber edtierbar, zeigt sich das Unterformular wie in Bild 3.<\/p>\n Bild 3: HTML-Editor-Unterformular in unberührtem Zustand<\/span><\/b><\/p>\n Neben dem Webbrowser-Control zur Eingabe des Textes findet sich in der rechten oberen Ecke noch ein unscheinbarer Button, der zum Ein- und Ausschalten der Formatierungen-Toolbars dient. Ein Klick auf ihn, und schon ändert sich das Erscheinungsbild des Unterformulars wie in Bild 4.<\/p>\n Bild 4: HTML-Editor mit eingeschalteter Toolbar zur Textformatierung<\/span><\/b><\/p>\n Sie können nun Text in das Webbrowser-Feld eingeben, Passagen markieren und Formatierungen über die Schaltflächen der Toolbar vornehmen, wie in Bild 5.<\/p>\n Bild 5: HTML-Editor-Unterformular im Einsatz<\/span><\/b><\/p>\n Es wäre müßig, hier die Formatierungsmöglichkeiten im Einzelnen zu erläutern. Öffnen Sie einfach die Beispielanwendung und fahren Sie mit der Maus über die Schaltflächen der Toolbar – im erscheinenden Tipptext wird dann die Bedeutung des Buttons angezeigt. <\/p>\n Sie können selbstverständlich das Unterformular noch weiter aufbohren und mit zusätzlichen Möglichkeiten versehen, in der aktuellen Ausführung dürfte es jedoch den meisten Anforderungen gerecht werden – schließlich geht es hier um ein einfaches Pseudo-Textfeld, nicht um den Nachbau von MS Word.<\/p>\n Unter Access 2000 erhalten Sie beim Öffnen des Formulars möglicherweise eine Fehlermeldung, die vom Befüllen der Combobox mit den Schriftartennamen herrührt.<\/p>\n Dieses Kombinationsfeld ist auf Werteliste als Datenherkunft eingestellt und wird über eine Hilfsfunktion GetFonts <\/b>mit einem semikolonseparierten String der Schriftartennamen bestückt.<\/p>\n Unter Access 2000 darf diese Werteliste nicht länger als 2.048 Zeichen lang sein, was hier schnell überschritten ist. Dafür ist in der Beispieldatenbank kein Workaround eingebaut.<\/p>\n Denkbar wäre etwa die Zuweisung einer Hilfstabelle an das Kombinationsfeld, die zuvor über die GetFonts<\/b>-Prozedur mit den Fontsnamen befüllt wurde, also eine direkte Datenbindung der Combobox.<\/p>\n Auf einige Spezialitäten des Editor soll hier doch noch eingegangen werden.<\/p>\n Als Schriftgröße werden die Zahlen 1 <\/b>bis 7 <\/b>verwendet, was nicht etwa als Größe in Punkt zu verstehen ist, sondern die in HTML übliche Größenanweisung darstellt.<\/p>\n An sich lassen sich über Style<\/b>-Angaben Schriftgrößen auch in Punkt angeben (style=“font-size:11pt“<\/b>), das würde dann aber wieder eine umfangreichere Programmierung erforderlich machen, weil die execCommand<\/b>-Methode im Verein mit der Anweisung FontSize<\/b> solche Angaben nicht erlaubt.<\/p>\n Ersatzweise müsste also das HTML über pasteHTML<\/b>, wie oben bereits ausgeführt, modifiziert werden.<\/p>\n Hyperlinks werden erzeugt, indem man den gewünschten Text markiert und auf die Hyperlink-Schaltfläche klickt. Dabei öffnet sich eine Inputbox zur Eingabe der Zieladresse. Sie wird anschließend über das <a href><\/b>-Tag in den HTML-Code eingesetzt. Dieser Link funktioniert dann allerdings nicht im Design-Modus on<\/b>.<\/p>\n Erst wenn der Bearbeitungsmodus abgeschaltet wird, reagiert der Mauszeiger auf den Link-Text. Wird der Link nun angeklickt, so öffnet sich die URL in einem externen Browser. Der Grund dafür ist sicher plausibel: Normalerweise würde das Webbrowser-Control selbstständig zur gewünschten URL navigieren.<\/p>\n Dann aber hätte man statt des editierten Textes ganz anderen Inhalt im Control und würde diesen unter Umständen fälschlicherweise abspeichern. Auch ein Zurück<\/b> zum vorigen per write<\/b>-Methode angelegten Text ist nicht möglich – dieser schwebt bereits im Nirvana.<\/p>\n Um das Navigieren zur Link-Adresse zu unterbinden, wird dieser Vorgang abgefangen. Dazu kann man sich des BeforeNavigate<\/b>-Ereignisses des Webbrowser-Controls bedienen. Das Ereignis gibt als Parameter unter anderem die URL an, zu der das Control navigieren möchte, und einen Parameter Cancel<\/b>, der den Vorgang dann abbricht, wenn er in der Ereignisprozedur auf True <\/b>gesetzt wird.<\/p>\n Die entsprechende Prozedur des Unterformulars vergleicht nun, ob es sich bei der Link-Adresse um about:blank<\/b> handelt, also das eigene Dokument, oder um einen externen Link. In letzterem Fall wird Cancel <\/b>auf True <\/b>gesetzt und stattdessen die Adresse einem externen Browser per Shellexecute <\/b>übergeben.<\/p>\n Umbrüche sind ein spezielles Thema in HTML. Zwar entspricht die Eingabetaste, die zu einem <p><\/b>-Tag (paragraph<\/b>) führt, schon dem gleichen Vorgang etwa unter Word.<\/p>\n Nur ist der Abstand der Absätze im Browser dann so groß, dass es wie eine Leerzeile wirkt. Deshalb wird im HTML-Unterformular das ENTER <\/b>zu einem Zeilenumbruch gemacht (<br><\/b>) und die Kombination STRG-ENTER <\/b>zu einem Absatzwechsel (<p><\/b>). Das kommt dem Verhalten gängiger Textverarbeitungen einfach näher.<\/p>\n Technisch ist die Sache ohnehin eine Speziallösung. Denn ein ActiveX-Steuerelement erhält unter Access die Eingabetaste grundsätzlich erst gar nicht mitgeteilt – auch dann nicht, wenn es den Fokus besitzt.<\/p>\n Warum Microsoft das so gestaltete, ist unklar. Deshalb ist es notwendig, im Formular die Tastenvorschau<\/b>-Eigenschaft auf Ja <\/b>zu stellen und alle KeyDown<\/b>-Events abzufangen. Alle Tasten-Codes bleiben unberührt bis auf den Wert 13<\/b>, der die ENTER<\/b>-Taste identifiziert.<\/p>\n Sobald dieser auftaucht, wird dem Dokument je nach möglichem Zustand der Kontrolltasten ein <br> <\/b>oder ein Absatzwechsel verpasst – Letzteres über die execCommand<\/b>-Methode InsertParagraph<\/b>.<\/p>\n Hier unterscheidet sich die Lösung übrigens deutlich von jener, die Stephen Lebans in seiner Demo verbaute. Stephen fängt zwar ebenfalls die ENTER<\/b>-Taste ab, ermittelt dann aber etwas umständlich per API das Browser-Fenster-Handle, um ihm dann mit SendKeys <\/b>die Tastencodes zu senden – eine in meinen Augen unnötige Verrenkung.<\/p>\n In der Toolbar des Unterformulars ist eine Schaltfläche mit einem Häkchen zu finden, die das Speichern des HTML-Inhalts in den Datensatz des Hauptformulars erwirkt. Eigentlich wäre dies überflüssig, denn bereits das Verlassen des HTML-Unterformulars zieht explizit dasselbe nach sich.<\/p>\n Da die Schaltfläche aber beim Webcontrol auch den Design-Modus abschaltet, ist eine Kontrolle des Ergebnisses möglich, solange man sich noch im Unterformular befindet.<\/p>\n Das Seitenlayout im Browser ändert sich nämlich teilweise etwas (Umbrüche!), wenn man zwischen beiden Modi umschaltet – zumindest lässt sich das beim Internet-Explorer 8 feststellen.<\/p>\n Code-Fragmente<\/p>\n Wie das HTML-Unterformular eingesetzt werden kann, sehen Sie am Formular frmPersonen <\/b>der Beispieldatenbank htmlform.mdb<\/b>. In seiner Load<\/b>-Prozedur werden alle Einstellungen für die Unterformularklasse vorgenommen:<\/p>\n Die wichtigste öffentliche Property ist BoundField<\/b>. Ihr übergibt man den Namen des Tabellen- oder Abfragefeldes, an das man den HTML-Text binden möchte. Im Beispiel ist dies das Memo-Feld Anmerkungen <\/b>der Formulartabelle tblPersonen<\/b>. <\/p>\n Weiter ist zwingend der Name des Unterformulars selbst in ParentControl <\/b>anzugeben, damit die Unterformularklasse dessen Ereignisse Beim Hineingehen <\/b>und Beim Verlassen <\/b>abfangen kann, um darauf mit dem Wechsel des Design-Modus reagieren zu können. (Offenbar gibt es aus einem Unterformular heraus keinen einfachen Weg, den Steuerelementnamen zu ermitteln, unter dem es im Hauptformular eingesetzt ist.)<\/p>\n Mit BackColor <\/b>kann man optional die Hintergrundfarbe für die Toolbar bestimmen. Im Beispiel wird dafür die gleiche Farbe genommen, die auch der Detailbereich aufweist.<\/p>\n ToolbarTimeout <\/b>ist ein Long<\/b>-Wert, der angibt, nach welcher Zeitspanne (in Millisekunden) sich die Toolbar automatisch ausblendet, wenn im HTML-Unterformular nichts passiert.<\/p>\n Wird er, wie im Beispiel, auf 0 <\/b>gesetzt, so bleibt der Toolbar dauerhaft sichtbar.<\/p>\n AllowEditMode <\/b>bestimmt, ob der Text im Steuerelement überhaupt bearbeitbar sein darf. Wird hier False <\/b>zugewiesen, wie oben, dann erscheint die Formatierungs-Toolbar erst gar nicht und die HTML-Anzeige befindet sich quasi im Readonly<\/b>-Modus. <\/p>\n Die Eigenschaft kann aber jederzeit neu gesetzt werden, was im Beispielformular dann geschieht, wenn der Button mit der Aufschrift Bearbeiten <\/b>ausgelöst wird (cmdEdit_Click<\/b>). Die Toolbar erscheint nun automatisch und der Design-Mode ist eingeschaltet.<\/p>\n Im Form_Resize<\/b>-Event wird das HTML-Unterformular auf brauchbare Breite und Höhe gebracht, sodass es immer den unteren Teil des Hauptformulars ausfüllt:<\/p>\n Unter Access 2007 kann man diesen Teil weglassen und stattdessen das Unterformular mit den Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker<\/b> verankern.<\/p>\n Unter Access 2000 funktioniert, wie erwähnt, zwar die Größenänderung für das Unterformular und das integrierte Webcontrol, der darin enthaltene Browser verbleibt jedoch in seinen einmal gespeicherten Abmessungen. Dafür gibt es bisher keine bekannte Lösung. Zwar kann er mit API-Funktionen vergrößert werden, funktioniert dann aber nicht mehr korrekt. Das bedeutet, dass unter Access 2000 das HTML-Unterformular eine feste Größe haben muss und man die Resize<\/b>-Prozedur auskommentieren kann.<\/p>\n Wenn Sie im Web-Control ein neues Dokument anlegen (about:blank<\/b>) oder zu einer neuen Seite navigieren (Navigate2<\/b>), dann ist es zunächst mit dieser Aufgabe beschäftigt, das jedoch in einem eigenen Thread, weshalb der VBA-Code sofort fortfährt. Auf den Inhalt des Controls, also das Document<\/b>-Objekt, können Sie aber erst zugreifen, wenn der Vorgang abgeschlossen ist. Zum Glück gibt es eine Status<\/b>-Eigenschaft im Web-Control, die Auskunft darüber gibt, ob ein Dokument fertig geladen ist, sodass man sie in einer Schleife abfragen kann:<\/p>\n Diese Hilfsprozedur wird erst verlassen, wenn der gewünschte ReadyState <\/b>erreicht ist. Gültig ist das Dokument in der Regel dann, wenn der Status READYSTATE_INTERACTIVE = 3 <\/b>entspricht. Diese Prozedur wird an verschiedenen Stellen im HTML-Unterformularcode aufgerufen.<\/p>\n In der Toolbar von sfrmHTML <\/b>finden Sie einen Button, durch den ein Rahmen um die im Dokument markierte Passage gezogen wird. Dabei wird nicht etwa eine Tabelle angelegt, sondern per Style<\/b>-Eigenschaft ein border<\/b>-Attribut gesetzt (Prozedur cmdFrame_Click<\/b>). Derlei lässt sich nicht per execCommand <\/b>bewerkstelligen, sondern muss durch Modifikation des HTML-Codes erfolgen:<\/p>\n Hier wird der Text mit einem SPAN<\/b>-Tag umrahmt und dessen Style <\/b>mit einem border<\/b>-Attribut versehen. Damit taucht ein kleines Problem auf: Diese Formatierung kann nicht über die Funktion queryCommandValue <\/b>abgefragt werden. Die entsprechende Umschaltfläche wird also nicht aktiv, wenn man später die Markierung auf diesen Bereich setzt. Auch das Entfernen der Formatierung (cmdDelFormat_Click<\/b>) klappt damit nicht mehr. In diesem Fall hilft nur das Löschen der kompletten Textpassage und Neueingabe.<\/p>\n Wollte man diesen Umstand ändern, so wäre einiges mehr an Programmierung nötig. Der HTML-Code des selection<\/b>-Objekts müsste analysiert und das SPAN<\/b>-Tag daraus gelöscht werden. Den HTML-Code der markierten Stelle erhalten Sie mit dieser Anweisung:<\/p>\n Schrift- und Hintergrundfarbe des ausgewählten Bereichs können mit Klick auf die dafür vorgesehenen Toolbar-Elemente geändert werden.<\/p>\n Es handelt sich dabei nicht um Schaltflächen, sondern um Bildsteuerelemente, deren Click<\/b>-Prozedur zum Aufruf des per API erzeugten Farbauswahldialogs von Windows führt (mdl_sfrmHTML<\/b>). Der Farbwert, den dieser Dialog zurückgibt, ist ein RGB-Long-Wert, der für HTML erst in die im Web übliche Hexadezimal-Syntax überführt werden muss, was über die Hilfsroutine MakeColorCode <\/b>geschieht:<\/p>\n Der Wert für Rosa <\/b>(13158655<\/b>) wird so zu #FFC8C8<\/b>.<\/p>\n Beim Wechsel eines Datensatzes im Hauptformular soll dem Web-Control der neue Inhalt des zugehörigen Tabellenfeldes zugewiesen werden. Damit das Unterformular diesen Wechsel überhaupt mitbekommt, muss es auf das Current<\/b>-Ereignis des Hauptformulars reagieren.<\/p>\n Zwar könnte man gleich im Hauptformular und dessen Current<\/b>-Ereignis den dafür benötigten Code platzieren, müsste ihn dann aber in jedem Formular wiederholen, welches ein HTML-Unterformular hostet. Um hier unabhängiger zu bleiben, wurde dieser Code in das Unterformular integriert.<\/p>\n Dafür ist ein Verweis auf das Hauptformular in Form der per WithEvents <\/b>deklarierten Objektvariablen frmParent <\/b>vorgesehen. Deren Current<\/b>-Ereignis wird aber nur ausgelöst, wenn die zugehörige Ereigniseigenschaft auch aktiviert ist:<\/p>\n Die Ereignis-Routine sieht dann so aus:<\/p>\n Als Erstes wird ein neues Dokument im Control über about:blank<\/b> angelegt und auf dessen Gültigkeit mit der besprochenen Hilfsfunktion WaitForReady <\/b>gewartet. Dann wird, falls es sich nicht um einen neuen Hauptdatensatz handelt (NewRecord<\/b>-Eigenschaft), der Inhalt des Tabellenfeldes ausgelesen. Um welches Feld es sich dabei handelt, wurde zuvor beim Initialisieren des Unterformulars als String in der Membervariablen m_Field <\/b>abgelegt. Schließlich wird der HTML-Text mit der write<\/b>-Methode in das Dokument geschrieben und ein Verweis auf das nun fertige Dokument in der Objektvariablen objDoc <\/b>abgelegt, die nun für weitere Verwendung und Formatierungen zur Verfügung steht.<\/p>\n Der Code für den umgekehrten Vorgang, das Auslesen des Dokuments und Speichern im Tabellen-feld, wird ausgeführt, sobald das Unterformular verlassen wird, was über ein ebenfalls abgefangenes Ereignis geschieht:<\/p>\n Aus der Dokumentvariablen wird über die body.outerHTML<\/b>-Eigenschaft der HTML-Text ermittelt und nur dann in das Tabellenfeld gespeichert, wenn dies über die Eigenschaft AllowEditMode <\/b>erlaubt wurde. Anschließend wird im Browser-Control der Bearbeitungsmodus abgeschaltet.<\/p>\n Zusammenfassung<\/b><\/p>\n Über das immer verfügbare Webbrowser-Control wird die Möglichkeit geschaffen, Texte unter Access formatierbar zu machen. Die vorgestellte Lösung über ein HTML-Unterformular lässt sich leicht in beliebige eigene Datenbanken übertragen.<\/p>\n Für den Produktiveinsatz sollten Sie sich allerdings den Code genauer ansehen. Möglicherweise benötigen Sie nicht alle der enthaltenen Formatierungsanweisungen oder Sie möchten vielleicht das Verhalten der ENTER<\/b>-Taste ändern.<\/p>\n Die Fehlerbehandlung im Klassenmodul ist auch nur ziemlich rudimentär gestaltet, weshalb gerade mal 350 Zeilen Code für das Projekt ausreichten. Trauen Sie sich und machen Sie Ihren eigenen Editor daraus!<\/p>\n Letzte Anmerkung: Versuchen Sie erst gar nicht, das Webbrowser-Control in einen Bericht einzubauen – es funktioniert nicht, und es gibt auch sonst kein ActiveX-Control, welches die Anzeige von HTML in Berichten leisten könne. Es bleibt nur der direkte Ausdruck des HTML-Dokuments, etwa über die execCommand<\/b>-Methode Print<\/b>. <\/p>\n Links<\/b><\/p>\n [1] Freie Richtext-ActiveX-Steuerelemente von Stephen Lebans und von vbAccelerator: http:\/\/www.lebans.com\/richtext.htm, http:\/\/www.vbaccelerator.com\/codelib\/richedit\/richedit.htm<\/p>\n [2] HTML-Editor-Demodatenbank von Stephen Lebans: http:\/\/www.lebans.com\/htmleditor.htm<\/p>\n [3] Referenz zur Internet-Explorer-Programmierung von Microsoft: http:\/\/msdn.microsoft.com\/en-us\/library\/aa752038%28VS.85%29.aspx<\/p>\n [4] Formatierung im Webbrowser per execCommand-Methode: http:\/\/msdn.microsoft.com\/en-us\/library\/aa220275%28office.11%29.aspx<\/p>\n Enthaltene Beispieldateien:<\/p>\n htmlform.zip<\/p>\n\n
Me!ctlHTML.Object.Navigate2 "http:\/\/www.access-im-unternehmen.de"<\/pre>\n
Me!ctlHTML.Object.Navigate2 "about:blank"<\/pre>\n
Me!ctlHTML.Object.Document.body.style.fontSize = "11pt"<\/pre>\n
Dim objDoc As MSHTML.HTMLDocument\r\nSet objDoc = Me!ctlHTML.Document\r\nWith objDoc\r\n .body.style.fontSize = "11pt"\r\nEnd With\r\nEine Alternative wäre auch dieser Code:\r\nDim objDoc As HTMLDocument\r\nDim objBody As HTMLBody\r\nSet objDoc = Me!ctlHTML.Document\r\nSet objBody = objDoc.body\r\nWith objBody\r\n .style.fontSize = "11pt"\r\n .style.font = "Arial"\r\nEnd With<\/pre>\n
Private WithEvents objDoc As MSHTML.HTMLDocument\r\n...\r\nSet objDoc = Me!ctlHTML.Document\r\n...\r\nPrivate Sub objDoc_onselectionchange()\r\n Debug.Print " Textauswahl wurde geändert"\r\nEnd Sub<\/pre>\n
Dim strHTML As String\r\nstrHTML = "<body><strong>TEST<\/strong><\/body>"\r\nctlHTML.Document.write strHTML<\/pre>\n
Dim objDoc As HTMLDocument\r\nSet objDoc = Me!ctlHTML.Document\r\nobjDoc.write strHTML<\/pre>\n
ctlHTML.Document.write Me!HTML_Memofeld.Value<\/pre>\n
ctlHTML.Document.designMode = "On"<\/pre>\n
Me!HTML_Memofeld.Value = ctlHTML.Document.body.outerHTML<\/pre>\n
ctlHTML.Document.designMode = "Off"\r\nSet objDoc = ctlHTML.Document<\/pre>\n
objDoc.execCommand "Bold"<\/pre>\n
objDoc.execCommand "Fontname", "Courier New"<\/pre>\n
objDoc. selection.createRange.pasteHTML "<em>TEST<\/em>"<\/pre>\n
strHTML = objDoc.selection.createRange.Text<\/pre>\n
strHTML = "<em>" & strHTML & "<\/em>"\r\nobjDoc. selection.createRange.pasteHTML strHTML<\/pre>\n
Wert = objDoc.selection.createRange.queryCommandValue ("Bold")<\/pre>\n![\"demo_form.png\"](\"..\/fileadmin\/_temp_\/2010_01\/Webbrowser-web-images\/demo_form_opt.jpeg\")
<\/p>\n![\"editmode_true.png\"](\"..\/fileadmin\/_temp_\/2010_01\/Webbrowser-web-images\/editmode_true_opt.jpeg\")
<\/p>\n![\"toolbar.png\"](\"..\/fileadmin\/_temp_\/2010_01\/Webbrowser-web-images\/toolbar_opt.jpeg\")
<\/p>\n![\"edit_text.png\"](\"..\/fileadmin\/_temp_\/2010_01\/Webbrowser-web-images\/edit_text_opt.jpeg\")
<\/p>\nWith Me!sfrmAnmerkungen.Form\r\n .BoundField = "Anmerkungen"\r\n Set .ParentControl = Me!sfrmAnmerkungen\r\n .BackColor = Me.Section(acDetail).BackColor\r\n .ToolbarTimeout = 0\r\n .AllowEditMode = False\r\nEnd With<\/pre>\n
With Me!sfrmAnmerkungen\r\n .Width = Me.InsideWidth - 600\r\n .Height = Me.InsideHeight -.Top - 120\r\nEnd With<\/pre>\n
Sub WaitForReady(Optional lState As Long = _\r\n READYSTATE_INTERACTIVE)\r\n If objHTML Is Nothing Then Exit Sub\r\n Do\r\n DoEvents\r\n Loop Until objHTML.ReadyState >= lState\r\nEnd Sub<\/pre>\n
objDoc.selection.createRange.pasteHTML _\r\n"<span style=""border-width:1px;border-style:solid"">" _\r\nobjDoc.selection.createRange.Text & "<\/span>"<\/pre>\n
strHTML = objDoc.selection.createRange.htmlText<\/pre>\n
Function MakeColorCode(AColor As Long) As String\r\n Dim strColor As String\r\n strColor = Hex(AColor)\r\n strColor = String(6 - Len(strColor), "0") & strColor\r\n strColor = Mid(strColor, 5) & Mid(strColor, 3, 2) & Left(strColor, 2)\r\n MakeColorCode = "#" & strColor\r\nEnd Function<\/pre>\n
frmParent.OnCurrent = "[Event Procedure]"<\/pre>\n
Private Sub frmParent_Current()\r\n Dim strHTML As String\r\n objHTML.Navigate2 "about:blank"\r\n WaitForReady\r\n If Not frmParent.NewRecord Then\r\n strHTML = Nz(frmParent.Controls(m_Field))\r\n End If\r\n If Len(strHTML) > 0 Then\r\n objHTML.Document.write strHTML\r\n End If\r\n Set objDoc = objHTML.Document\r\nEnd Sub<\/pre>\n
Private Sub ctlParent_Exit(Cancel As Integer)\r\n Dim strHTML As String\r\n strHTML = objDoc.body.outerHTML\r\n If m_AllowEdit Then _\r\n frmParent.Controls(m_Field).Value = strHTML\r\n objDoc.designMode = "Off"\r\n End Sub<\/pre>\n
Downloads zu diesem Beitrag<\/h3>\n