<\/p>\n
Es gibt zahlreiche Anwendungsbereiche für einen eingebetteten Webbrowser in Access-Formularen. Ob es um die statische Anzeige von HTML-Dateien geht, um dynamisch generierte Webseiten, die etwa Berichte ausgeben, oder um die Nutzung von Webservices. Microsoft hat dies erkannt und in Access 2010 das neue Webbrowser-Steuerelement eingeführt. Während es einfach ist, den Inhalt einer Webseite von VBA aus zu steuern, sei der Content nun durch Stringverkettung erzeugt oder über das DOM-Objektmodell des Browsers, wird es schwierig, von einer eingebetteten Webseite aus über Skripte auf Access und VBA zuzugreifen, um etwa Daten abzuholen. Wie das dennoch geht, finden Sie im Folgenden beschrieben.<\/b><\/p>\n
Webbrowser-Steuerelemente<\/b><\/p>\n
Bis zu Access 2010 ist es notwendig, den Internet Explorer als ActiveX-Steuerelement in ein Formular einzufügen. Über das Entwurfsmenü Einfügen|ActiveX-Steuerelement…|Microsoft Web Browser <\/b>wird ein Browser-Fenster im Detailbereich angelegt. Der Internet Explorer, egal in welcher Version, stellt dieses Control von Haus aus zur Verfügung. Das Control hat also mit Access oder dessen Installation selbst nichts zu tun.<\/p>\n
In Access 2010 bedient man sich der Steuerelementesammlung im Entwurfs-Ribbon und wählt das Webbrowser-Steuerelement aus (s. Bild 1).<\/p>\n
![\"A2010CtlRibbon.png\"](\"..\/fileadmin\/_temp_\/2011_03\/WebbrowserVBABridge-web-images\/A2010CtlRibbon.png\")
<\/p>\n
Bild 1: Auswahl des Webbrowser-Steuerelements im Entwurf-Ribbon von Access 2010<\/span><\/b><\/p>\n Dieses neue Steuerelement ist im Grunde nichts anderes als ein Wrapper für das ActiveX-Control des Internet Explorers. Es weist somit weitgehend die gleichen Eigenschaften und Methoden auf. Der wesentliche Unterschied besteht darin, dass dieses Element sich direkt an ein Feld der Datenherkunft des Formulars binden lässt.<\/p>\n Dabei muss es sich um ein Textfeld handeln, das die URL der Seite enthält, zu welcher navigiert werden soll. HTML-Code kann man hier nicht direkt übergeben.<\/p>\n Dem ActiveX-Control hingegen muss man per VBA sagen, welche Seite es anzeigen soll. Dazu bedient man sich der Methode Navigate2 <\/b>des Objekts:<\/p>\n In diesem Fall wird eine leere Webseite im Browser angelegt. Tatsächlich funktioniert dasselbe auch mit dem Webbrowser-Steuerelement von Access 2010, das diese Methode eigentlich gar nicht kennt.<\/p>\n Der feine Unterschied liegt hier in der Ansprache einmal des Steuerelements selbst (Me!ctlWeb<\/b>) und davon abweichend des enthaltenen Steuerelements (Me!ctlWeb.Object<\/b>). Das letztere Objekt stellt die Webbrowser<\/b>-Klasse der Bibliothek ShDocVw <\/b>dar, auf die automatisch ein Verweis im VBA-Projekt hinzugefügt wird – sowohl im Falle des ActiveX-Controls, wie auch beim Access 2010-Steuerelement. Damit stehen dann auch im Access 2010-Steuerelement dieselben Eigenschaften und Methoden des DOM-Objektmodells der MSHTML-Bibliothek zur Verfügung.<\/p>\n Meist wird man das Steuerelement im Formular so ausstatten, dass es die verfügbare Breite einnimmt. Bei veränderbaren Formularen ist es dann bis Access 2007 notwendig, im Resize<\/b>-Ereignis des Formulars das Webbrowser-Steuerelement neu zu dimensionieren, indem man seine Eigenschaften Width <\/b>und Height <\/b>setzt.<\/p>\n Das klappt allerdings nur in Access 2003. In früheren Versionen ändert sich die einmal im gespeicherten Entwurf gesetzte Größe nicht und wird auf ewig beibehalten. <\/p>\n Unter Access 2007 und 2010 verwenden Sie dafür das Verankern-Feature (Tab Anordnen|Position|Anker<\/b>) und stellen das Control etwa auf Nach unten und quer dehnen <\/b>ein.<\/p>\n Web-Inhalte laden<\/b><\/p>\n Häufig werden Sie einfach nur eine Webseite im Internet darstellen wollen. Das Laden dieser Webseite erledigt wieder die Navigate2<\/b>-Methode des Webbrowsers:<\/p>\n Ebenso können Sie natürlich eine lokal im Dateisystem vorhandene HTML-Datei aufrufen. Als Parameter dient dann der ganz normale Pfad, wie sie ihn auch im Explorer angeben würden.<\/p>\n Interessant wird es, wenn Sie den Inhalt der Webseite dynamisch erzeugen möchten. Eine gängige Methode ist es, den HTML-Code dabei als String in VBA zusammenzusetzen, diesen lokal als Datei abzuspeichern und die Datei schließlich ins Webbrowser-Steuerelement zu laden. Dabei können etwa auch Inhalte aus Tabellen, die über Recordsets ausgelesen werden, zum Zuge kommen. <\/p>\n Einfacher, da ohne Umweg über das Dateisystem, kann dem Browser aber der Inhalt auch direkt zugewiesen werden. Dafür gibt es die write<\/b>-Methode des geladenen Dokuments.<\/p>\n Der einzige Grund, das Dateisystem zu bemühen, wären Webseiten, die Grafiken oder Bilder enthalten. In diesem Fall müssen die Bilddateien parallel zu den aufgerufenen HTML-Dateien im Verzeichnis liegen. Per write <\/b>oder andere Methoden gibt es keine Möglichkeit, Bildobjekte in eine Seite zu bekommen.<\/p>\n Ausnahme sind hier Systeme mit installiertem Internet Explorer 9, dem man neuerdings über HTML5 oder SVG dynamisch Bilder über Skripte und das MSHTML-Modell zuweisen kann. Aber das wäre Thema für einen weiteren Beitrag.<\/p>\n Web-Inhalte schreiben<\/b><\/p>\n Das Vorgehen, um den HTML-Code über die write<\/b>-Methode in die Browser-Seite zu schreiben, lässt sich anhand Listing 1<\/a><\/span> verdeutlichen, das in der Beispieldatenbank im Formular frmWeb <\/b>zu finden ist.<\/p>\n Listing 1: Webinhalt dynamisch schreiben<\/p>\n Damit die write<\/b>-Methode überhaupt angewandt werden kann, muss im Browser bereits ein Dokument geladen sein – schließlich ist write <\/b>eine Methode des Document<\/b>-Objekts.<\/p>\n Und das lässt sich am einfachsten erledigen, indem zunächst eine leere Seite mit about:blank <\/b>erzeugt wird.<\/p>\n In der Prozedur sehen Sie, dass eine Hilfsvariable CWeb <\/b>eingesetzt wird, die in der Prozedur nicht deklariert ist. Diese enthält einen Verweis auf das Webbrowser-Steuerelement und ist im Kopf des Moduls so deklariert, dass sie Ereignisse auslösen kann:<\/p>\n Die Zuweisung geschieht im Load<\/b>-Ereignis des Formulars:<\/p>\n In weiteren Prozeduren des Formulars kann fortan diese Objektvariable verwendet werden, statt der länglichen Form mit dem Verweis auf das Steuerelement. <\/p>\n Nachdem der Browser angewiesen wurde, ein leeres Dokument zu erzeugen, kann auf dieses in VBA noch nicht unmittelbar zugegriffen werden. Der Browser braucht dafür einige Zeit, die asynchron zum VBA-Code abläuft.<\/p>\n Aus diesem Grund gibt es den Aufruf einer Warteschleife, die in die zusätzliche Prozedur WaitForReady <\/b>ausgelagert ist:<\/p>\n Der Browser gibt anhand eines Flags der Eigenschaft ReadyState <\/b>kund, wie es um den Zustand des Dokuments bestellt ist. Ist dieser Wert größer oder gleich 3<\/b>, was der Konstanten READYSTATE_INTERACTIVE <\/b>entspricht, dann steht das Dokument für den Zugriff bereit.<\/p>\n Das geladene Dokument wird im weiteren Verlauf der Objektvariablen oDoc <\/b>zugewiesen, die im Prozedurkopf As Object <\/b>deklariert ist. An sich könnte man dafür auch gleich den korrekten Typ HTMLDocument <\/b>verwenden. Doch in diesem Fall streikt VBA beim Aufruf der write<\/b>-Methode wegen inkompatibler Variant-Datentypen.<\/p>\n Im String sHTML <\/b>wird der Inhalt der Seite zusammengestellt. Dabei muss man sich vergegenwärtigen, dass das leere Dokument bereits durchaus HTML-Code enthält – nämlich die Elemente HTML <\/b>und BODY<\/b>. Die write<\/b>-Methode schreibt also innerhalb der body<\/b>-Tags.<\/p>\n Wie am Listing zu erkennen ist, können dabei auch mehrere write<\/b>-Anweisungen hintereinander folgen. Der Code wird dann sequenziell in die Seite geschrieben.<\/p>\n Um zu demonstrieren, dass die Seite auch anders als durch HTML-Code zu beeinflussen ist, wird ihre Hintergrundfarbe über das DOM-Modell manipuliert, was über die style<\/b>-Eigenschaft background <\/b>des body<\/b>-Elements geschieht.<\/p>\n Nach dem Auslösen der Prozedur über die Schaltfläche (s. Bild 2) ändert sich das Browser-Fenster und zeigt die rudimentäre Webseite an.<\/p>\n Bild 2: Das per VBA generierte Webformular im Browser-Steuerelement<\/span><\/b><\/p>\n Der HTML-Code der Variablen sHTML <\/b>im Listing besteht aus einem HTML-Formular mit einem input<\/b>-Element, also einer Schaltfläche, die direkt eine Zeile Javascript ausführt, nämlich die Anzeige eines Meldungsfensters.<\/p>\n Es lässt sich festhalten, dass dem Webbrowser-Steuerelement Web-Inhalte unmittelbar per VBA zugewiesen und dabei auch Javascript-Abschnitte integriert werden können.<\/p>\n Javascript-Funktionen per VBA aufrufen<\/b><\/p>\n Üblicherweise werden Javascript-Funktionen in Webseiten dazu verwendet, um auf Aktionen zu reagieren, welche von Ereignissen hervorgerufen werden. In der Regel handelt es sich dabei um Elemente innerhalb eines form<\/b>-Tags, wie eben der input<\/b>-Button in Bild 2.<\/p>\n Andere Ereignisquellen könnten das Laden der Seite selbst sein, Maus-Klick-Events auf bestimmte Elemente oder Zeitgeber, die in Intervallen Aufgaben erledigen sollen.<\/p>\n Geht der Umfang des Scripts über eine Zeile hinaus, dann werden solche Funktionen im Interesse besserer Strukturierung separat in den Quelltext geschrieben, anstatt, wie im Beispiel, das Skript direkt in das Element<\/b>-Tag einzubinden. Der Quelltext hätte alternativ so wie in Listing 2<\/a><\/span> ausgesehen.<\/p>\n Listing 2: Einfache Webseite mit Javascript-Funktion<\/p>\n Hier wird im input<\/b>-Element angegeben, dass auf Klick die Skript-Funktion fuScript <\/b>aufgerufen werden soll.<\/p>\n Interessant wäre nun, wenn sich solche Funktionen, die ja auch weit umfangreicher programmiert sein können, nicht nur durch Ereignisse der Webseitenelemente ausführen ließen, sondern auch direkt aus VBA heraus.<\/p>\n <\/p>\n Das würde eventuell umfangreiche Manipulationen der Seite über das Objektmodell DOM <\/b>überflüssig machen, denn über Javascripte lassen sich Webinhalte erheblich einfacher steuern als über MSHTML. <\/p>\n Tatsächlich ist dies auf verblüffend einfache Weise möglich. Das window<\/b>-Objekt des DOM-Modells kennt die Anweisung execScript<\/b>, mit der beliebige Skripte im Quelltext aufgerufen werden können. Dabei wird sogar ein etwaiger Rückgabewert der Funktion berücksichtigt. An das window<\/b>-Objekt kommt man wiederum einfach über die Eigenschaft parentWindow <\/b>eines geladenen Dokuments.<\/p>\n Dieses window<\/b>-Objekt stellt im Prinzip das Rahmenfenster des Browsers beziehungsweise eines Browser-Tabs dar.<\/p>\n Um das Skript in Listing 2 anzusprechen, reicht eine einzige VBA-Zeile aus:<\/p>\n Wichtig ist, dass die Klammern für die Funktion mit angegeben werden. Innerhalb dieser Klammern können Sie auch Parameter übergeben, falls die Javascript-Funktion diese verlangen sollte. Selbstverständlich hat die Parameter-Syntax als String exakt so auszusehen, als würde die Funktion von einem Web-Element oder einem anderen Javascript aufgerufen. <\/p>\n Im Formular frmIDocHost <\/b>der Beispieldatenbank finden Sie ein Beispiel dafür. Dort löst die Schaltfläche cmdExecScript <\/b>eine Prozedur aus, welche die Zeile oben aufruft. Nur die Meldung wurde, wie in Bild 3 zu sehen, etwas verändert.<\/p>\n Bild 3: Aufruf einer Javascript-Funktion aus VBA heraus<\/span><\/b><\/p>\n Im zweiten Teil des Beitrags zeigen wir Ihnen, wie sich diese Schnittstelle von VBA nach Javascript gewinnbringend einsetzen lässt, um eine GoogleMaps-Seite zu steuern.<\/p>\n VBA-Funktionen von Javascript aus aufrufen<\/b><\/p>\n So einfach sich die Schnittstelle in Richtung Browser gestaltet, so kompliziert wird sie leider in die andere. Woher sollen schließlich eine Webseite oder das Webbrowser-Steuerelement wissen, in welcher Anwendung sie zum Einsatz kommen und wo sie eingebettet sind<\/p>\n Dafür gibt es zwei speziell vorbereitete Schnittstellen des Internet Explorers, die Interfaces IDocHostUIHandler <\/b>und ICustomDoc<\/b>. Der Mechanismus sieht im Prinzip so aus:<\/p>\n Ist eine Webseite im Browser geladen, dann fragt das Webbrowser-Steuerelement in der Applikation, die es enthält, nach, ob diese das COM-Interface IDocHostUIHandler <\/b>unterstützt.<\/p>\n Im Fall des in einem Access-Formular enthaltenen Webbrowser-Steuerelements ist das die Formularklasse, die befragt wird. Diese muss das Interface implementiert haben.<\/p>\n Fällt die Antwort positiv aus, dann ruft der Browser, je nach Situation und Zustand, verschiedene Methoden des Interfaces auf. Die wichtigste davon ist die Funktion GetExternal<\/b>. Sie verlangt als Rückgabewert das Klassenobjekt, das quasi als Rahmen für Skripte im Browser herhalten soll.<\/p>\n Man übergibt ihr etwa die Formularklasse, also Me<\/b>. Daraufhin leitet jede Angabe des window.external<\/b>-Objekts in Javascript genau auf diese Klasse und ihre Methoden. Ist etwa im Formular eine VBA-Funktion fuTest() <\/b>untergebracht, dann kann Javascript diese so ansprechen:<\/p>\n Das ist allerdings noch nicht die ganze Wahrheit. Damit der Browser überhaupt nach dieser Schnittstelle fragt, ist zuvor noch anzugeben, wo er nachfragen soll, wo sich also die Klasse mit dem implementierten Interface befindet. Diese ist ihm über Umwege mitzuteilen:<\/p>\n Erst muss wieder ein spezielles Interface des Browsers bemüht werden, das ICustomDoc<\/b>. Es ist automatisch in jedem geladenen Web-Dokument implementiert.<\/p>\n Man kann deshalb per Set<\/b>-Anweisung ein HTMLDocument <\/b>auf ein ICustomDoc <\/b>casten. Und schließlich übergibt man mit dessen Methode SetUIHandler <\/b>dem Browser die Information, dass die Formularklasse das Objekt der Begierde ist.<\/p>\n Wie funktioniert dieses kompliziert wirkende Gebilde nun in der Realität<\/p>\n Schnittstellen bereitstellen<\/b><\/p>\n Zuerst brauchen wir die Definitionen der Schnittstellen ICustomDoc <\/b>und IDocHostUIHandler<\/b>. Leider sind diese in keiner Bibliothek zu finden, die Windows mitbringen würde. Daher wird eine externe Typbibliothek gebraucht, die diese Interface-Deklarationen enthält.<\/p>\n Wie so oft wird man bei E. Morcillos Bibliothek olelib.tlb <\/b>fündig, die einen großen Teil der COM-Interfaces und Objektklassen enthält, welche von Windows und seinen Komponenten intern verwendet werden. Die Bibliothek ist Teil des Downloads zu diesem Beitrag, heißt aber, da etwas modifiziert, olelib_moss.tlb<\/b>.<\/p>\n Diese Bibliothek muss als Verweis in das VBA-Projekt eingebunden werden. Im Unterschied zu ActiveX-Komponenten muss eine Typbibliothek in Form einer .tlb<\/b>-Datei nicht zwingend im System registriert werden.<\/p>\n Es reicht, wenn VBA die Datei findet. Das ist allerdings eben nicht der Pfad der Datenbankdatei, denn der wird in die Suche nicht einbezogen.<\/p>\n Die .tlb<\/b>-Datei sollte deshalb in das Systemverzeichnis von Windows gespeichert werden, also etwa windows\\system32 <\/b>oder windows\\SysWOW64 <\/b>bei 64bit-Windows. Leider sind hierfür wieder mal Administratorrechte nötig.<\/p>\n Handler definieren<\/b><\/p>\n Nun muss dem Webbrowser-Steuerelement gesagt werden, welche Klasse den IDocUIHost<\/b>-Handler bereitstellt. Wie erwähnt, läuft das über das Interface ICustomDoc<\/b>, das seinerseits Bestandteil eines jeglichen Webdokuments ist.<\/p>\n Ein solches muss also zunächst geladen sein, was abermals über ein leeres mit about:blank <\/b>erzeugtes Dokument läuft. Ein passendes Ereignis des Webbrowser-Steuerelements schließlich, in dem auf das Document<\/b>-Objekt zugegriffen werden kann, ist DocumentComplete<\/b>.<\/p>\n Im Formular legen Sie also eine Ereignisprozedur dafür an und statten sie mit einem Code wie in Listing 3<\/a><\/span> aus.<\/p>\n Listing 3: Setzen des UI-Handlers auf die Formularklasse<\/p>\n Im Verlauf wird zuerst die Hilfsvariable ICDoc <\/b>vom Typ ICustomDoc <\/b>per Set<\/b>-Anweisung auf das Web-Dokument gecastet und dann die Formularklasse Me <\/b>über die Methode SetUIHandler <\/b>übergeben.<\/p>\n Anschließend reagiert die Webseite mit dem Abfragen der Handler-Schnittstelle.<\/p>\n Handler-Schnittstelle implementieren<\/b><\/p>\n Wie angedeutet, muss die Formularklasse nun das Interface IDocHostUIHandler <\/b>bereitstellen. Die Klasse muss so tun, als hätte sie diese Schnittstelle eingebaut. Und dafür gibt es unter VBA die Direktive Implements<\/b>, die im Kopf des Klassenmoduls unterzubringen ist.<\/p>\n Sobald das geschehen ist, will VBA beim Kompilieren, dass alle Schnittstellenmethoden in der Klasse vorhanden sind, und meldet sonst einen Fehler (s. Bild 4).<\/p>\n Bild 4: Fehlermeldung, wenn nicht alle Methoden einer Schnittstelle vorhanden sind<\/span><\/b><\/p>\n Also wählen Sie im linken Kombinationsfeld des Code-Editors erst den Eintrag IDocHostUIHandler <\/b>aus und anschließend aus dem rechten nacheinander die Schnittstellenmethoden.<\/p>\n Dabei werden dann automatisch die passenden Prozedurrümpfe angelegt, etwa dieser:<\/p>\n Diese Prozeduren müssen zwar vorhanden sein, interessieren uns aber nicht weiter, bis auf die GetExternal<\/b>-Prozedur, die mit Leben zu füllen ist.<\/p>\n Im Formular frmIDocHost <\/b>der Beispieldatenbank sind dennoch rein informativ in die einzelnen Schnittstellenprozeduren Zeilen zur Ausgabe in einem Textfenster enthalten. Sie sehen damit, wie der Browser beim Abfragen der Schnittstelle tickt (s. Bild 5).<\/p>\n Bild 5: Die Schnittstellenmethoden werden vom Browser aufgerufen<\/span><\/b><\/p>\n Bleibt noch der letzte Teil der Übung, nämlich dem window<\/b>-Objekt des Browsers zu sagen, auf was dessen external<\/b>-Objekt zu verweisen hat:<\/p>\n Der Rückgabewert der Schnittstellenfunktion ist einfach Me<\/b>, also die Formularklasse selbst. Hier könnte man übrigens genauso gut eine andere Objektvariable, etwa eines zusätzlichen Klassenmoduls, angeben.<\/p>\n Damit ist die Rückkopplung zwischen Javascript und VBA perfekt. Um die VBA-Funktionen des Formularklassenmoduls aus Javascript aufzurufen, muss nun lediglich deren Namen an das external<\/b>-Objekt angehängt werden:<\/p>\n Weist die VBA-Funktion Parameter auf, so sieht der Aufruf etwa dergestalt aus:<\/p>\n Hier sollte die VBA-Funktion als ersten Parameter eine Zahl enthalten, als zweiten einen String.<\/p>\n Das Gesamtkunstwerk finden Sie im angesprochenen Formular der Beispieldatenbank (s. Bild 5).<\/p>\n Klicken Sie auf der Webseite auf das Button<\/b>-Element, so wird über das External<\/b>-Objekt eine VBA-Funktion im Formular aufgerufen, die schlicht das Quadrat der als Parameter übergebenen Zahl berechnet und zurückgibt. Das Javascript zeigt das Ergebnis anschließend mit einem Meldungsfenster an.<\/p>\n Praktischer Einsatz<\/b><\/p>\n Die bisherigen Beispiele waren wohl eher didaktischer Natur, auch wenn man sich mit etwas Fantasie allerlei Verwendungszwecke für diese Bridge ausdenken kann.<\/p>\n So könnte man etwa Daten aus einem Recordset an das Javascript übergeben und dort weiterverarbeiten, um etwa Tabellen oder Textfelder zu füllen.<\/p>\n Weil aber immer wieder Fragen zum Umgang mit in Formulare eingebetteten Google Maps die Runde machen, soll im Weiteren beschrieben werden, wie die Bridge hier sinnvoll eingesetzt werden könnte.<\/p>\n Google Maps steuern<\/b><\/p>\n Das Formular frmGooglemaps <\/b>der Beispieldatenbank ist im Prinzip genau so aufgebaut, wie das oben beschriebene Formular mit der Implementation des IDocHostUIHandlers<\/b>.<\/p>\n Nur wird hier die Webseite nicht dynamisch erzeugt, sondern eine Webadresse aufgerufen, in der Code zum Anzeigen einer Google Maps-Karte enthalten ist, wenn Sie auf die Schaltfläche Maps-URL laden <\/b>klicken. Das sieht dann so aus wie in Bild 6.<\/p>\n Bild 6: Das Beispielformular mit Webbrowser und geladener Google Maps-Seite<\/span><\/b><\/p>\n Die Funktionalität von Google Maps wird komplett über Javascripte erreicht. Wie diese zu programmieren sind, kann an dieser Stelle nicht dargestellt werden, denn die Möglichkeiten sind zu umfangreich. Wir verweisen auf die API-Dokumentation zu GoogleMaps [2], die auch zahlreiche Code-Beispiele enthält, wie die Skripte zu gestalten und die Seiten anzulegen sind.<\/p>\n Den Quelltext finden Sie im Download in der Datei mapsrouter.htm <\/b>und zusätzlich als kommentierten Text im Modul GooglemapsHTML <\/b>der Datenbank.<\/p>\n Sollten Sie diesen als Basis für eigene Seiten verwenden wollen, dann bedenken Sie, dass der im Kopf des Skript-Codes enthaltene erforderliche API-Key nur für unsere Webadresse gilt und gegen Ihren eigenen ausgetauscht werden muss. Anderenfalls wird Google beim Aufruf der Seite eine entsprechende Meldung ausgeben und einige Funktionen, wie das Routing, deaktivieren.<\/p>\n Unsere Seite ist so aufgebaut, dass sie eigentlich auch ohne Fremdsteuerung auskäme. Sie können die Karte verschieben, den Zoom-Modus einstellen oder zwischen Satelliten- und Kartendarstellung umschalten. Bei einfachem Klick auf die Karte werden Marker auf ihr erstellt, die die Wegpunkte für eine Strecke festhalten, zwischen denen anschließend die Streckenführung geroutet werden kann. Das Ergebnis können Sie in Bild 7 begutachten. <\/p>\n Bild 7: Per VBA aufgerufenes Strecken-Routing in GoogleMaps mit Ausgabe der Punktkoordinaten<\/span><\/b><\/p>\n Die Besonderheit besteht darin, dass eine Interaktion zwischen den Skripten der Seite und VBA-Funktionen im Formular stattfindet, wofür die zuvor erläuterte Bridge zum Einsatz kommt.<\/p>\n Zunächst können Sie über eine Formularschaltfläche das Routing auslösen. Dabei wird eine Javascript-Funktion angesprungen.<\/p>\n Außerdem können Sie spaßeshalber ein Tannensymbol mitten in Berlin über die Schaltfläche Marker setzen <\/b>einfügen.<\/p>\n Der Clou aber ist, dass eine Javascript-Funktion nach vollzogenem Routing die einzelnen Punktkoordinaten der Strecke an eine VBA-Funktion im Formular ausgibt, die sie dann im unteren Teil des Formulars in einem Textfeld auflistet. <\/p>\n In diesem Info-Fenster werden zusätzlich die Weltkoordinaten des Mauszeigers über der Karte ausgegeben, wenn Sie das Kontrollkästchen MouseOver <\/b>melden aktiviert haben.<\/p>\n Interaktion in Kürze<\/b><\/p>\n Nach dem Laden der Webseite wird die VBA-Javascript-Bridge wie zuvor beschrieben aktiviert. Der Klick auf Marker setzen <\/b>führt diese Zeile aus:<\/p>\n Hier wird also eine Javascript-Funktion vbaMarker <\/b>der Seite aufgerufen und es werden ihr als Parameter die Längen- und Breitengrade des zu setzenden Markers übergeben. Die Skript-Funktion hat dabei den Quelltext aus Listing 4<\/a><\/span>.<\/p>\n Listing 4: Javascript zum Setzen eines Markers in Google Maps<\/p>\n Die Funktion erwartet die Marker-Koordinate als Eingangsparameter, zeigt diese zur Kontrolle in einem Meldungsfenster an, zentriert die Karte auf den Ort und erzeugt schließlich das Marker-Objekt, welches wiederum auf einem GLatLng<\/b>-Objekt basiert. Der Code zum Setzen des Tan-nensymbols (GIcon<\/b>) für den Marker ist im Listing ausgespart.<\/p>\n Auf ähnliche Weise wird das Routing angestoßen:<\/p>\n Hier das zugehörige Javascript:<\/p>\n In der Routine wird Google Maps gesagt, dass es über das directions<\/b>-Objekt die Strecke finden soll, die zwischen den per Markern gesetzten Punkten liegt, welche zuvor im globalen Array points <\/b>zwischengespeichert wurden.<\/p>\n In geschweiften Klammern sind einige benannte Optionen für die Streckenführung gesetzt, wie etwa der Fußgänger-Modus.<\/p>\n Danach hat Google zu tun und berechnet die Route.<\/p>\n Wenn es fertig ist, dann teilt es dies der Seite über ein Ereignis mit, welches zuvor beim Laden der Seite erst aktiviert worden sein muss:<\/p>\n Das bedeutet, dass Google Maps die Skript-Funktion calcready <\/b>aufruft, wenn das Ergebnis auf deren Servern vorliegt. Diese Funktion sehen Sie in Listing 5<\/a><\/span>.<\/p>\n Listing 5: Ermitteln der Wegpunkte der Route und Übergabe dieser an VBA<\/p>\n Das Skript ruft nun gleich dreimal eine VBA-Funktion über das External<\/b>-Objekt im Formular auf, die den Namen VBAFunction <\/b>trägt. Diese führt unterschiedliche Operationen aus, die im ersten angegebenen Parameter gewünscht werden – etwa die Ausgabe der Zahl von Wegpunkten, wenn als Operator der String vertexcount <\/b>angegeben ist.<\/p>\n Man hätte ebenso drei unterschiedliche Funktionen des Formulars einsetzen können, die jede eine bestimmte Aufgabe erfüllen.<\/p>\n Der Übersichtlichkeit halber nahmen wir nur eine Funktion, die den Operator-String innerhalb eines Select Case<\/b>-Statements auswertet und in den einzelnen Zweigen die gewünschten Aufgaben erledigt (s. Listing 6<\/a><\/span>).<\/p>\n Listing 6: Die vom Javascript aufgerufene VBA-Prozedur für unterschiedliche Aufgaben<\/p>\n Viel passiert hier allerdings nicht. Es werden lediglich Informationen über Operation und Parameter an die Hilfsfunktion OutputText <\/b>übergeben, welche ihrerseits die Zeilen in ein Textfeld des Formulars schreibt.<\/p>\n Die vom Skript übermittelten Wegkoordinaten ließen sich natürlich auch sinnvoller weiterverwenden, indem man sie etwa in einer Tabelle abgespeichert und sie damit später jederzeit zur Verfügung stünden.<\/p>\n Interessant ist hier, dass die Funktion zwei optionale Parameter aufnehmen kann. Das Javascript kann also wahlweise zwei, einen oder gar keinen Parameter an das External<\/b>-Objekt übergeben. Das ließe sich beliebig fortsetzen.<\/p>\nMe!ctlWeb.Object.Navigate2 "about:blank"<\/pre>\n
Me!ctlWeb.Object.Navigate2 "http:\/\/www.access-im-unternehmen.de"<\/pre>\n
Private Sub cmdScriptor_Click()\r\n Dim oDoc As Object\r\n Dim sHTML As String\r\n CWeb.Navigate2 "about:blank"\r\n WaitForReady\r\n Set oDoc = CWeb.Document\r\n sHTML = "<form><input type=""button"" value=""Knopf"" onClick=""javascript:alert(''Huhu!'');""><\/input><\/form>"\r\n oDoc.write sHTML\r\n oDoc.body.Style.background = CStr("#D0D0B0")\r\n oDoc.write "Seite mit Knopf"\r\nEnd Sub<\/pre>\nPrivate WithEvents CWeb As SHDocVw.WebBrowser<\/pre>\n
Set CWeb = Me!ctlWeb.Object<\/pre>\n
Private Sub WaitForReady()\r\n Do\r\n DoEvents\r\n Loop Until CWeb.ReadyState >= READYSTATE_INTERACTIVE\r\nEnd Sub<\/pre>\n
![\"frmWeb.png\"](\"..\/fileadmin\/_temp_\/2011_03\/WebbrowserVBABridge-web-images\/frmWeb.png\")
<\/p>\n<script type="text\/javascript">\r\nfunction fuScript() {\r\n alert(''Huhuu!'');\r\n}\r\n<\/script>\r\n<form>\r\n <input type="button" value="Knopf" onClick="fuScript()"\/>\r\n<\/form><\/pre>\nWeb.Document.parentWindow.execScript "fuScript()"<\/pre>\n
![\"frmIDocHost1.png\"](\"..\/fileadmin\/_temp_\/2011_03\/WebbrowserVBABridge-web-images\/frmIDocHost1.png\")
<\/p>\nwindow.external.fuTest();<\/pre>\n
Private Sub ctlWeb_NavigateComplete2(ByVal pDisp As Object, URL As Variant)\r\n Dim ICDoc As ICustomDoc\r\n Dim V As Variant\r\n Set ICDoc = CWeb.Document\r\n ICDoc.SetUIHandler Me\r\n Set ICDoc = Nothing\r\nEnd Sub<\/pre>\n
Implements IDocHostUIHandler<\/pre>\n
![\"ImplementsError.png\"](\"..\/fileadmin\/_temp_\/2011_03\/WebbrowserVBABridge-web-images\/ImplementsError.png\")
<\/p>\nPrivate Sub IDocHostUIHandler_EnableModeless(ByVal fEnable As olelib.BOOL)\r\nEnd Sub<\/pre>\n
![\"UIHandlerMsgs.png\"](\"..\/fileadmin\/_temp_\/2011_03\/WebbrowserVBABridge-web-images\/UIHandlerMsgs.png\")
<\/p>\nPrivate Function IDocHostUIHandler_GetExternal() As Object\r\n Set IDocHostUIHandler_GetExternal = Me\r\nEnd Function<\/pre>\n
window.external.fuFormularfunktion();<\/pre>\n
window.external.fuFormularfunktion(8 €šTrowitzsch€™);<\/pre>\n
![\"frmGoogleMaps.png\"](\"..\/fileadmin\/_temp_\/2011_03\/WebbrowserVBABridge-web-images\/frmGoogleMaps.png\")
<\/p>\n![\"router.png\"](\"..\/fileadmin\/_temp_\/2011_03\/WebbrowserVBABridge-web-images\/router.png\")
<\/p>\nCWeb.Document.parentWindow.execScript "vbaMarker(52.6,13.4)"<\/pre>\n
function vbaMarker(lat,lng){\r\n alert(''Setze nun Marker auf '' + lat + ''\/'' + lng);\r\n var coord = new GLatLng(lat,lng);\r\n map.setCenter(coord, 12);\r\n marker = new GMarker(coord);\r\n map.addOverlay(marker);\r\n}<\/pre>\nCWeb.Document.parentWindow.execScript "calculate()"<\/pre>\n
function calculate() {\r\n map.clearOverlays();\r\n directions.loadFromWaypoints(points, _\r\n {avoidHighways:true, _\r\n travelMode:G_TRAVEL_MODE_WALKING});\r\n}<\/pre>\nGEvent.addListener(directions, ''load'', calcready);<\/pre>\n
function calcready() {\r\n pline=directions.getPolyline();\r\n nodes=pline.getVertexCount();\r\n window.external.VBAFunction(''message'',''Die Route besteht aus '' + nodes + '' Punkten.'');\r\n nodes = pline.getVertexCount()\r\n window.external.VBAFunction(''vertexcount'',nodes);\r\n for (i = 0; i < nodes; i++) {\r\n coord = pline.getVertex(i);\r\n window.external.VBAFunction(''vertexcoord'',coord.lat(),coord.lng());\r\n }\r\n}<\/pre>\nPublic Function VBAFunction(sFunktion As String, _\r\n Optional Param1 As Variant, Optional Param2 As Variant) As String\r\n Dim sRet As String\r\n sRet = "OK"\r\n Select Case sFunktion\r\n Case "message"\r\n OutputText "MESSAGE: " & Param1\r\n Case "vertexcount"\r\n OutputText "Punktzahl ist " & Param1\r\n Case "vertexcoord"\r\n OutputText "Wegkoordinate: " & Param1 & " \/ " & Param2\r\n Case "marker"\r\n OutputText "Marker gesetzt auf " & Param1 & " \/ " & Param2\r\n Case "mousemove"\r\n If Me!chkMouseover.Value = True Then\r\n OutputText "Cursor liegt auf " & Param1 & " \/ " & Param2\r\n End If\r\n Case Else\r\n OutputText "Hä"\r\n sRet = "!Unbekannt!"\r\n End Select\r\n VBAFunction = sRet\r\nEnd Function<\/pre>\n