<\/p>\n
Im August 2012 verteilte Microsoft über Windows-Update für alle Office-Installationen ab Version 2003 automatisch Security Patches, die nur eine einzige Komponente austauschten: die ActiveX-Bibliothek mscomctl.ocx, welche, unter anderem, das viel verwendete TreeView-Steuerelement enthält. Dabei machte die COM-Version der Bibliothek einen Sprung von 2.0 auf 2.1, was VBA-Module, in denen deren Elemente angesprochen werden, teilweise inkompatibel macht. Ergebnis sind deshalb Datenbanken, die seltsame Fehler melden, wenn Formulare mit TreeViews oder Listviews aufgerufen werden. <\/b><\/p>\n
In Foren und Blogs wurden Workarounds für das Problem diskutiert, die im Wesentlichen Manipulationen der Registry vorschlagen, und auch Microsoft veröffentlichte schließlich einen Patch zum Patch, ohne jedoch das Problem an sich zu lösen. Mit solchen Workarounds, die zudem Administratorrechte erfordern, mag man am Einzelplatz glücklich werden, wer aber Datenbanken für Unternehmen mit Dutzenden von Arbeitsplätzen entwickelt, steht vor ärgerlichen Umständen.<\/p>\n
Die Auffassung von IT-Verantwortlichen, dass ActiveX-Komponenten zu vermeiden seien, bekommt hier verständlicherweise neue Nahrung. Dabei war die MSComCtl-Bibliothek bisher relativ unverdächtig – ist sie doch Bestandteil der Office-Installation selbst.<\/p>\n
Das wirft die Frage auf, ob diese Steuerelemente denn nicht durch andere Lösungen zu ersetzen wären. Und selbstverständlich gibt es diese. Mögliche Alternativen sind API-Module, die etwa ein TreeView-Fenster nativ von Grund auf neu erstellen. Schwierigkeiten bekommt man hier indessen meist mit den notwendigen Subclassing-Routinen, die VBA instabil werden lassen.<\/p>\n
Auch existieren Lösungen, die TreeViews allein mit Access-Bordmitteln realisieren. Von den Features, dem Komfort und der Performance her können diese allerdings nicht wirklich mit dem ActiveX-Pendant konkurrieren.<\/p>\n
Schaut man sich um, so findet man TreeViews aber nicht alleine in Anwendungen, sondern etwa auch auf Internetseiten, wo sie häufig Navigationszwecken dienen.<\/p>\n
Diese TreeViews sind zumeist in JavaScript oder PHP programmiert. Es gibt sie in zahlreichen Varianten – umfangreiche oder simple, mit oder ohne AJAX. Und viele können von den Möglichkeiten her durchaus mit dem MSComCtl-TreeView mithalten. Was liegt da näher, als solch ein geskriptetes TreeView in einem Webbrowser-Steuerelement anzuzeigen<\/p>\n
So begab ich mich auf die Suche nach einem JavaScript-TreeView, das in den Möglichkeiten dem ActiveX-TreeView nahekommt. Einige Internetseiten bieten einen Überblick über freie TreeViews.<\/p>\n
Nach dem Test diverser Lösungen fiel die Wahl auf das CoolJSTree<\/b>, welches in einer abgespeckten freien sowie in einer umfangreicheren Bezahlversion (Professional) angeboten wird. <\/p>\n
Das CoolJSTree<\/p>\n
Sie finden diese Script-Lösung unter http:\/\/javascript.softdrawer.com\/scripts\/cooltree <\/b>zum Download.<\/p>\n
Das Paket enthält zahlreiche Beispiele, die Sie sofort im Browser begutachten können. Eine übersichtliche Dokumentation fehlt ebenfalls nicht. <\/p>\n
Im Prinzip brauchen Sie die folgenden Dateien für ein CoolJSTree<\/b>-TreeView:<\/p>\n Es können aber, wie etliche der vom Entwickler beigesteuerten Beispiele zeigen, die Skripte natürlich auch zu einer kompakten Datei zusammengefasst oder sogar in das anzuzeigende HTML-Dokument selbst eingebaut werden. Dann müssen außer dieser HTML-Datei nur noch die Bilddateien vorhanden sein.<\/p>\n Von der Tabelle in den Browser<\/b><\/p>\n Wie aber kommt das JavaScript-TreeView als Steuerelement in ein Access-Formular, wie werden seine Knoten angelegt und gesteuert<\/p>\n Zuerst braucht es hier ein Webbrowser Control, das Access 2010 bereits als Steuerelement beisteuert, während frühere Versionen auf das ActiveX-Steuerelement Microsoft Web Browser angewiesen sind.<\/p>\n Beide sind im Prinzip identisch und stellen einen kleinen Internet Explorer zur Verfügung, nur die Steuerung über das Objektmodell fällt marginal unterschiedlich aus. Das Steuerelement ziehen Sie auf die Ausmaße, die das TreeView haben soll. Ab Access 2007 können Sie es schließlich noch verankern – etwa mit der Option Quer nach unten dehnen <\/b>-, wodurch es sich zur Laufzeit der Formulargröße anpasst.<\/p>\n Inhalt wird in das Control üblicherweise über dessen Methode Navigate2 <\/b>und Angabe einer HTML-Datei als Parameter geladen. Ob diese aus dem Internet bezogen wird oder lokal, spielt dabei keine Rolle.<\/p>\n Man könnte also über VBA einen HTML-String zusammenbauen, der die Elemente des TreeViews und das JavaScript enthielte, und ihn anschließend als HTML-Datei abspeichern, damit der Webbrowser sie laden kann – wäre da nicht das Rechtesystem und Zonenmodell des Internet Explorers! Denn das Webbrowser-Steuerelement weigert sich beharrlich, jegliches JavaScript in lokalen Dateien auszuführen.<\/p>\n Auch änderungen an den Zoneneinstellungen des Internet Explorers ändern daran nichts. Allerdings gibt es einen Trick, dem Browser einen Netzwerkpfad vorzugaukeln, wodurch dieser offenbar andere Sicherheitseinstellungen verwendet. Schreiben Sie den Pfad zur Datei als URL beispielsweise in dieser Form:<\/p>\n Mit dieser Pfadangabe (hier: Laufwerk C:<\/b>) führt der Browser dann seltsamerweise auch integrierte JavaScripts aus.<\/p>\n Es gibt jedoch eine wesentlich elegantere Form, dem Control zur Anzeige von HTML-Inhalten zu verhelfen, als über den Umweg einer dynamisch erzeugten Datei.<\/p>\n Legen Sie zunächst ein leeres Dokument im Control an und schreiben Sie anschließend beliebigen Inhalt über die write<\/b>-Methode desselben in es hinein. Das könnte so aussehen:<\/p>\n Die write<\/b>-Methode löst im Browser das erneute Rendern der Seite mit dem Inhalt der String-Variablen sHTML <\/b>aus.<\/p>\n Das gezeigte Beispiel wird allerdings so nicht funktionieren, weil Sie vor dem Absetzen der write<\/b>-Anweisung noch abwarten müssen, bis das leere Dokument komplett erzeugt ist. Dazu müsste vor der letzten Zeile noch über die ReadyState<\/b>-Eigenschaft des WebControls der Status des Dokuments abgefragt werden, der mindestens den Wert Interactive <\/b>haben muss. Das kann etwa mittels einer Schleife geschehen:<\/p>\n Statt des simplen HTML-Strings oben ist nun der Aufbau der TreeView-Seite mitsamt den integrierten Skripten der Variablen sHTML zuzuweisen. Wie das in der Demo zum Beitrag gelöst ist und wie auf Ereignisse des TreeViews reagiert werden kann, erfahren Sie in den folgenden Abschnitten.<\/p>\n Eine einfache Demo-Anwendung<\/p>\n In der Demodatenbank TreeViewJS.mdb <\/b>existiert ein Formular frmSample<\/b>, das sich nach Klick auf die Schaltfläche Lade TreeView <\/b>wie in Bild 1 präsentiert.<\/p>\n Bild 1: Einfaches Formular mit JavaScript-TreeView im Webbrowser-Steuerelement<\/span><\/b><\/p>\n Beim Laden des Formulars wird lediglich die Objektvariable oTree <\/b>auf das WebControl<\/b>-Objekt gesetzt:<\/p>\n Das wäre für den weiteren Code nicht unbedingt nötig, vereinfacht aber die Schreibweise im Modul.<\/p>\n Die eigentliche Routine zum Laden des TreeViews steht hinter dem Click-Ereignis cmdLoad_Click <\/b>des Formulars. Nachdem hier ein leeres HMTL-Dokument im WebControl angelegt wurde, holt sich die Prozedur zuerst den Inhalt der Datei tree_template.html <\/b>in eine String-Variable sDoc<\/b>. Der Pfad zur Datei ist hier hartkodiert und steht auf dem Unterverzeichnis \\trees <\/b>der Datenbank; passen Sie das gegebenenfalls an. Im String werden dann diverse Platzhalter mit Inhalt gefüllt und abschließend der HTML-String einfach in das leere Dokument geschrieben:<\/p>\n Schon füllt sich das Browser-Fenster mit dem TreeView, in dem Sie die einzelnen Nodes mit der Maus ein- und ausklappen können.<\/p>\n Was hier in Kurzform dargestellt wurde, ist in Wirklichkeit natürlich etwas umfangreicher – die Prozedur verzweigt in verschiedene Unterfunktionen, die den Inhalt für die Platzhalter bereitstellen. Zunächst aber einiges zum Aufbau des HTML-Templates selbst.<\/p>\n Das Tree-Template<\/b><\/p>\n Statt der oben erwähnten drei eingebundenen CoolJSTree<\/b>-JavaScripts sind deren Routinen alle in das Template selbst aufgenommen. Es enthält also alles, was eine HTML-Datei benötigt, und zusätzlich vier Skript-Abschnitte. Der wichtigste ist ganz am Ende zu finden:<\/p>\n Mit der Funktion COOLjsTree <\/b>wird der Baum tatsächlich erstellt. Als Parameter werden eine beliebige Klassen-ID für den DIV<\/b>-Abschnitt des TreeView erwartet, eine Variable, die die Nodes des Baums definiert, und eine Variable, die die Formatierungsanweisungen enthält. Die Funktion selbst ist im Skript-Block darüber mit seinem etwas kryptischen Code enthalten.<\/p>\n Die Variable TREE_FORMAT <\/b>für die Formatierungen ist oben gleich nach dem BODY<\/b>-Tag definiert. Dort steht kommentiert, welche Formatierungsmöglichkeiten fest vergeben werden können. Das sind etwa Angaben zu Einrückungen, Positionierung und vor allem zu den Icons. Der Aufbau des Blocks ist in der CoolJSTree<\/b>-Dokumentation gut beschrieben. Das Interessante an den Abschnitten für die Icons sind die Pfadangaben zu den Bilddateien, die etwa so aussehen:<\/p>\n Da die Icons irgendwo vom Browser gelesen werden müssen, es aber keine relative URL geben kann – das Dokument wurde ja aus dem Nichts per about:blank <\/b>erzeugt -, müssen hier absolute Pfade stehen. Und deshalb sind die Dateinamen mit drei Fragezeichen als Präfix versehen.<\/p>\n Diese Platzhalter werden später per VBA durch das tatsächliche Icon-Verzeichnis ersetzt:<\/p>\n Der Vollständigkeit halber nachfolgend ein kleines Schnipsel, wie sich aus einem Windows-Pfad die URL für das Verzeichnis bildet:<\/p>\n <\/p>\n Statt der im icons<\/b>-Verzeichnis mitgelieferten Icons können Sie selbstverständlich beliebige andere Bilddateien verwenden, die auch nicht zwingend im Format 16 x 16 daherkommen müssen. Das CoolJSTree <\/b>passt seine Zeilen automatisch der Symbolgröße an.<\/p>\n Im TREE_FORMAT<\/b>-Block steht allerdings nicht, wie die Texte des TreeViews formatiert werden sollen. Diese Node-Texte stellen allesamt A-Tags, also Hyperlinks dar. Also kann man sie einfach mit einer CSS-Style-Definition formatieren, die im HEAD<\/b>-Abschnitt der HTML-Datei enthalten ist:<\/p>\n Viel ist das nicht – aber Sie werden sich denken können, dass auch hier das $$$ <\/b>nur ein Platzhalter ist, der später per VBA mit der tatsächlichen Definition ersetzt wird, damit das TreeView von Access aus formatiert werden kann.<\/p>\n Die entsprechende Funktion im Formular dafür nennt sich GetStyleString() <\/b>und bastelt einfach die Style-Anweisungen hartkodiert zusammen. (Vorgriff: In der anderen in der Beispieldatenbank enthaltenen Demo wird dieser Style-String allerdings dynamisch aus Klasseneigenschaften zusammengesetzt.)<\/p>\n Bliebe noch die Variable TREE_ITEMS <\/b>als Parameter für die COOLjsTree<\/b>-Funktion. Darin müssen die Nodes, also die Struktur des Baums, definiert sein. Das COOLJSTree <\/b>sieht dafür etwa folgenden Aufbau vor:<\/p>\n Jeder durch eine Zahl symbolisierte Node wird durch eine geöffnete und eine geschlossene rechteckige Klammer angegeben. Innerhalb der Klammer können jedoch wiederum weitere Nodes stehen, sodass eine hierarchische Struktur entsteht. Im Beispiel ist 0 <\/b>das Root-Node, dem als Kindelemente die Nodes 1<\/b>, 2<\/b>, 3 <\/b>und 4 <\/b>untergeordnet sind. Der Node 4 <\/b>seinerseits beherbergt die Unterelemente 5 <\/b>und 6<\/b>.<\/p>\n Statt der Zahlen sind jeweils mindestens drei Parameter einzusetzen: Optional die ID des Elements, zwingend sein Text, die URL für den Hyperlink, das Hyperlink-Zielfenster beziehungsweise Ziel-Frame und optional ein für den jeweiligen Node spezifischer Formatierungs-String. Beispiel für einen Node-Eintrag:<\/p>\n Ein Mausklick auf den Node mit der ID 3 <\/b>und der Aufschrift Mein Node-Text<\/b> führte dazu, dass im selben Browser-Fenster zu http:\/xyz.com <\/b>navigiert würde – zu diesem Umstand später mehr. Die Variable TREE_ITEMS <\/b>ist im Template so codiert:<\/p>\n Abermals finden Sie hier einen Platzhalter, der im Formular dann über die Prozedur GetMenuString <\/b>ersetzt wird, in der übrigens, wie bei den Styles, der Node-Aufbau hartkodiert ist:<\/p>\n Über dieses Template-System lässt sich schön die Baumstruktur dynamisch anlegen und anzeigen. Nebenbei sei erwähnt, dass das Template statt über eine Datei genauso gut auch aus einem Memo-Feld einer Tabelle bezogen werden könnte.<\/p>\n Auf Klicks reagieren<\/b><\/p>\n Üblicherweise will man bei Klick auf einen Node ein Ereignis auslösen und darauf reagieren. Das lässt sich mit dem CoolJSTree <\/b>recht einfach realisieren, weil alle Nodes Hyperlink-Ziele enthalten.<\/p>\n Ein Klick führt also dazu, dass ein neues Dokument geladen werden will. Das aber kann man mit der Ereignisprozedur BeforeNavigate <\/b>des WebControls abfangen (s. Listing 1<\/a><\/span>).<\/p>\n Listing 1: Prozedur, die durch das Ereignis BeforeNavigate ausgelöst wird<\/p>\n URL ist in der Ereignisprozedur der Parameter, welcher das Hyperlink-Ziel zurückgibt. Findet die Routine hier am Ende ein x <\/b>oder ein y<\/b>, so erfolgt eine Spezialbehandlung. Das macht deshalb Sinn, weil in der Demo ein Node etwa so definiert wird:<\/p>\n Als Hyperlink wurde 3x <\/b>angegeben, also die Node-ID mit einem Suffix x<\/b> kombiniert, was zur URL about:3x <\/b>führt, weil about:blank <\/b>quasi das Root-Verzeichnis der Webseite ist.<\/p>\n Per String-Behandlung wird zuerst die ID aus der URL ermittelt, die weiterverwendet werden kann – hier zur Ausgabe in einem Bezeichnungsfeld – und schließlich der Parameter Cancel <\/b>auf True <\/b>gesetzt. Das führt dazu, dass eben nicht zum Hyperlink-Ziel navigiert, der Sprung also abgebrochen wird, und das TreeView im Browser stehen bleibt, als wäre nichts geschehen.<\/p>\n Gibt es Anwendungsfälle für dieses einfache Formular<\/p>\n Da der Inhalt des TreeViews statisch ist, könnte man es etwa zu Navigationszwecken benutzen, um andere Formulare oder Berichte aufzurufen, oder aber, um eine Dokumentation bereitzuhalten, wie in Winhelp- oder CHM-Help-Dateien. Wenn lediglich hierarchische Strukturen dargestellt werden sollen, können Sie gar auf die Routine in BeforeNavigate <\/b>verzichten.<\/p>\n TreeView im Unterformular<\/p>\n Wesentlich mächtiger ist da die zweite Lösung der Demo-Datenbank, die das TreeView in einem TreeView-Unterformular namens sfrmHTMLTreeView <\/b>anzeigt, welches in das Hauptformular frmHTMLTreeView <\/b>eingebettet ist – s. Bild 2.<\/p>\n Bild 2: Gesteuertes JavaScript-TreeView im Unterformular<\/span><\/b><\/p>\n Das Unterformular sfrmHTMLTreeView <\/b>enthält ein komplexes Klassenmodul, über dessen Eigenschaften und Methoden sich die Nodes und Formatierungen des TreeView steuern lassen. Die komplette Beschreibung aller enthaltenen Funktionen würde den Rahmen dieses Beitrags sprengen. Daher im Folgenden nur eine Zusammenfassung der wichtigsten Features und Tricks.<\/p>\n Wie in der vorhergehenden Demo zeigt sich das TreeView erst nach Klick auf den Button Lade TreeView<\/b>. Danach werden auch die abgebildeten Schaltflächen sichtbar. Der Button für den Quellcode öffnet Notepad mit dem Quelltext der erzeugten HTML-Seite. Damit können Sie kontrollieren, was der VBA-Code aus dem Template anstellte.<\/p>\n Mit ändere Font <\/b>wird dem TreeView ein neuer Style verpasst, was komfortabel über die Font<\/b>– und HoverFont<\/b>-Eigenschaften des Klassenmoduls geschieht. <\/p>\n Mit ändere Cursor <\/b>wird statt des Pfeils ein Handsymbol für den Mauszeiger im TreeView angezeigt. Dies geschieht mittels einer einzigen Zeile:<\/p>\n Diese Eigenschaft wird vom Modul in Style-Definitionen für das A<\/b>-Tag übersetzt (Prozedur GetStyleString<\/b>), wie im Übrigen auch die Font<\/b>– und Hintergrundeigenschaften.<\/p>\n Dass auch gezielt ein Node per ID über VBA angesprungen und in den sichtbaren Bereich gescrollt werden kann – Stichwort: EnsureVisible <\/b>– zeigt der nächste Button.<\/p>\n Toggle Node-ID 319 <\/b>bewirkt, dass ein Verzeichnis-Knoten per Code ein- und ausgeklappt wird. Dazu muss lediglich die Methode ToggleNode <\/b>unter Angabe der ID des Knotens aufgerufen werden.<\/p>\n Genauso wenig fehlen Routinen, um den kompletten Baum auf- und zuzuklappen (ExpandAll<\/b>, CollapseAll<\/b>).<\/p>\n An dieser Stelle die Erläuterung, wie die Nodes überhaupt angelegt werden. Das Hauptformular erzeugt die Nodes aus einer Tabelle tblMenu <\/b>mit rekursivem Inhalt und Tausend Datensätzen über die Methode AddItem <\/b>des Klassenmoduls. Diese erwartet folgende Parameter:<\/p>\n sText <\/b>ist der anzuzeigende Text des Node, ID <\/b>seine eindeutige ID, die vorzugsweise aus dem Primärschlüssel einer Tabelle kommt, ParentID <\/b>verweist auf den Eltern-Node mit entsprechender ID und Image <\/b>schließlich gibt optional ein von den Standard-Icons abweichendes Symbol für den Node an.<\/p>\n Diese Bilddatei muss im gleichen Verzeichnis liegen, wie die anderen und darf keine Pfadangabe enthalten, sondern nur den Dateinamen!<\/p>\n Das Klassenmodul speichert alle Node-Angaben zunächst in einem Array ab, um diese später beim Anzeigen des TreeViews in der Routine GetMenuString <\/b>in die Struktur zu überführen, die das CoolJSTree <\/b>erwartet. Dass dies nicht so ganz einfach ist, zeigt ein Blick in die immerhin 50 Zeilen lange Funktion samt Aufruf einer rekursiven Unterfunktion GetSubItems<\/b>. <\/p>\n Zurück zu den Formatierungsmöglichkeiten. Der Button Färbe Node-IDs 1185\/6 <\/b>lässt die Nodes mit den IDs 1185 <\/b>und 1186 <\/b>erscheinen und färbt sie nachträglich ein, wie in Bild 3 zu sehen.<\/p>\n Bild 3: Einfärben von Element-Texten<\/span><\/b><\/p>\n Dies geschieht dynamisch, ohne dass der Baum neu aufgebaut werden muss! Dazu ein Code-Ausschnitt:<\/p>\n Die entscheidende aufgerufene Funktion lautet hier HTMLElementFromId<\/b>. Das Klassenmodul hält sie bereit, um aus der ID eines Nodes seine DOM-Klassen-ID zu ermitteln und das entsprechende HTML-Element zurückzugeben.<\/p>\n Diese DOM-ID hat mit der bei AddItem <\/b>übergebenen ID gar nichts zu tun und lautet im Beispiel etwa nttree1_39an<\/b>.<\/p>\n Auf das HTML-Element kann man nun beliebige Aktionen ausführen. Im Objektmodell zu IHTMLElement findet man tonnenweise Anweisungen, wovon die Style<\/b>-Eigenschaften nur einen kleinen Bruchteil darstellen. Genaugenommen handelt es sich bei einem Node-Element im CoolJSTree <\/b>um ein HTMLAnchorElement<\/b>. Sehen Sie sich im Objektkatalog an, was sich mit diesem anstellen lässt.<\/p>\n ähnliches passiert, wenn Sie einen Node im Baum anklicken. Das ruft die Ereignisprozedur ItemClick <\/b>des Klassenmoduls auf:<\/p>\n Das Ereignis übergibt folgende Parameter:<\/p>\n Damit hat man ausreichend Informationen beisammen, um auf den Klick zu reagieren. Unter anderem etwa das Neuformatieren des Textes über die DOMID<\/b>, wie dies auch in der Demo passiert (s. Bild 4):<\/p>\n Bild 4: Klick auf einen Node formatiert diesen dynamisch um.<\/span><\/b><\/p>\n Einen Pferdefuß hat die Sache allerdings: Sie können nur Nodes ansprechen, die auch tatsächlich im TreeView sichtbar sind. Ein nicht sichtbarer Node existiert beim Rendering noch nicht und deshalb gibt es auch noch keine Klassen-ID für diesen. Daher müssen Sie erst die Methode EnsureVisible <\/b>aufrufen. Alternativ können Sie auch den gesamten Baum per ExpandAll <\/b>ausklappen, die Nodes formatieren und ihn dann wieder per CollapseAll <\/b>einklappen.<\/p>\n In diesem Fall sind bereits alle nötigen HTML-Elemente angelegt, auch wenn sie nicht sichtbar sind.<\/p>\n Und schließlich können Sie auch auf das Browser-Fenster selbst zugreifen und es steuern. Der Button Tree scrollen <\/b>zeigt ein Beispiel. <\/p>\n Das Klassenmodul hat eine Eigenschaft HTMLWindow<\/b>, die das HTMLWindow2<\/b>-Objekt des WebControls zurückgibt, und dieses weist ebenso zahllose Methoden und Eigenschaften auf. So etwa die scrollBy<\/b>-Methode:<\/p>\n Das scrollt den Baum um 16 Pixel nach oben.<\/p>\n Das HTMLWindow2<\/b>-Objekt aus folgendem Ausdruck erhalten:<\/p>\n Um noch einige Interna der Klasse zu erläutern: Das CoolJSTree <\/b>veröffentlicht sogar selbst zwei Objekte – das Tree<\/b>-Objekt und das Node<\/b>-Objekt. Das Tree<\/b>-Objekt erhält man raffiniert über das Window<\/b>-Objekt und in der Klasse wird es in der Variablen JSTree<\/b> gespeichert:<\/p>\n Hier hat man also in einer VBA-Variablen ein JavaScript-Objekt gespeichert! In der API-Dokumentation zu CoolJSTree <\/b>findet man etwa die Funktion NodeByID <\/b>zum Tree<\/b>-Objekt, welche ein CoolJSTree<\/b>-Node-Objekt für eine übergebene ID zurückgibt. Diese Funktion kann man allerdings nicht etwa so verwenden, wie bei Objektmethoden unter VBA üblich. Ein Aufruf etwa wie<\/p>\n\n
file:\/\/127.0.0.1\/c$\/meinverzeichnis\/test.html<\/pre>\n
WebControlObject.Navigate2 "about:blank"\r\nsHTML = "<HTML><BODY>Hallo!<\/BODY><\/HTML>"\r\nWebControlObject.Document.write sHTML<\/pre>\n
Do\r\n DoEvents\r\nLoop Until WebControlObject.ReadyState >= READYSTATE_INTERACTIVE<\/pre>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2012_06\/HTMLTreeview-web-images\/pic001.png\")
<\/p>\n Private WithEvents oTree As SHDocVw.WebBrowser\r\n Set oTree = Me!ctlWeb.Object<\/pre>\n
oTree.Document.write sDoc<\/pre>\n
<script type="text\/javascript">\r\n var tree = new COOLjsTree("tree1", TREE_ITEMS, TREE_FORMAT);\r\n <\/script><\/pre>\n ["folder.png", "folderopen.png", "page.png"]<\/pre>\n
sDoc = Replace(sDoc, "", sIconPath)<\/pre>\n
sIconPath = CurrentProject.Path & "\\trees\\icons\\"\r\n sIconPath = Replace(sIconPath, "\\", "\/")\r\n sIconPath = "file:\/\/" & sIconPath<\/pre>\n
<head>\r\n <style type="text\/css">\r\n §§§\r\n <\/style>\r\n <\/head><\/pre>\n
[0,[1],[2],[3],[4,[5],[6]]]<\/pre>\n
[{"id":3}, ''Mein Node-Text'', ''http:\/xyz.com'', ''_self']<\/pre>\n <script type="text\/javascript">\r\n var iconpath;\r\n iconpath="";\r\n var TREE_ITEMS = [@@@];\r\n <\/script><\/pre>\n
sMenu = GetMenuString()\r\n sDoc = Replace(sDoc, "@@@", sMenu)<\/pre>\n
Private Sub oTree_BeforeNavigate2(ByVal pDisp As Object, URL As Variant, Flags As Variant, TargetFrameName As Variant, PostData As Variant, Headers As Variant, Cancel As Boolean)\r\n If Right(URL, 1) = "x" Or Right(URL, 1) = "y" Then\r\n Dim sRet As String\r\n Dim n As Long\r\n n = InStrRev(URL, "\\")\r\n sRet = Mid(URL, n + 1)\r\n sRet = Replace(sRet, "about:", "")\r\n LblInfo.Caption = "Click auf " & sRet\r\n Cancel = True\r\n End If\r\nEnd Sub<\/pre>\n
[{"id":3}, ''Node-Text'', ''3x'', null]<\/pre>\n![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2012_06\/HTMLTreeview-web-images\/pic002.png\")
<\/p>\n oTree.Cursor = eTreeCursorHand<\/pre>\n
Function AddItem(ByVal sText As String, _\r\n ID As Long, _\r\n Optional ParentID As Long, _\r\n Optional Image As String)<\/pre>\n
![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2012_06\/HTMLTreeview-web-images\/pic003.png\")
<\/p>\n Dim oNode As IHTMLElement\r\n Set oNode = oTree.HTMLElementFromId(1185)\r\n With oNode.Style\r\n .backgroundColor = "#a0a0f0"\r\n .FontWeight = "700"\r\n .Color = "#ff4040"\r\n End With<\/pre>\n
Sub oTree_ItemClick(ByVal ID As Long, _\r\n ByVal Text As String, _\r\n ByVal DOMID As Variant, _\r\n ByVal IsFolder As Boolean, _\r\n ByVal sImage As String)<\/pre>\n
\n
![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2012_06\/HTMLTreeview-web-images\/pic004.png\")
<\/p>\n Dim oNode As IHTMLElement\r\n Set oNode = oTree.HTMLElementFromId(MID)\r\n oNode.Style.Color = "#ff4040"<\/pre>\n
oTree.HTMLWindow.scrollBy 0, -16<\/pre>\n
WebControl.Document.parentWindow<\/pre>\n
Dim JSTree As Object\r\n Set JSTree = oDoc.parentWindow.window.CTrees.tree1<\/pre>\n
Set Node = JSTree.NodeById (1185)<\/pre>\n