<\/p>\n
Für manche Aufgaben benötigen auch Datenbanken die Anzeige oder Auswahl von Dateien oder Ordnern des Betriebssystems. Manche davon lassen sich mit dem Dateiauswahldialog von Office erledigen. Hin und wieder ist aber eine unmittelbare Einsicht in das Dateisystem nützlich. Der Windows Explorer lässt sich mit Einschränkungen fernsteuern, doch schicker wäre ein Explorer direkt in einem Formular. Und das geht!<\/b><\/p>\nExplorer Browser Control aus Windows<\/h2>\n
Den Explorer komplett nachzubilden, ist in der Regel mit gewaltigem Aufwand verbunden. Hier sind unzählige Shell<\/b>-Objekte zu berücksichtigen. Wer etwa das Access 2007 Praxisbuch<\/b> kennt, findet in der zentralen Beispielanwendung dmsBase<\/b> ein ActiveX-Steuerelement<\/b> ShellExplorer.ocx<\/b>, das zur Laufzeit weitgehend dem Windows Explorer gleicht. Die Programmierung dieses Controls benötigte über 20.000 Zeilen Code.<\/p>\n
Diese Zeiten sind seit Windows Vista<\/b> vorbei! Microsoft hat hier ein neues Control in den Shell<\/b>-Komponenten verbaut, welches sich ExplorerBrowser<\/b> nennt. Dabei handelt es sich um einen kompletten Explorer mit allem Zubehör als einbettbares Fenster. In gewisser Weise ähnelt diese Komponente dem Webbrowser Control<\/b>, welches den Internet Explorer <\/b>als ActiveX-Steuerelement zur Verfügung stellt. Nur gibt es die ExplorerBrowser<\/b>-Komponente eben leider nicht als ActiveX-Control. Sie muss stattdessen über COM-Schnittstellen<\/b> erzeugt und gesteuert werden. Das wäre weiter nicht tragisch, enthielte denn irgendeine Windows-Bibliothek, die sich in die Verweise<\/b> von VBA eintragen ließe, die entsprechenden Schnittstellendefinitionen. Das ist jedoch nicht der Fall.<\/p>\nOLEEXP<\/b> als Nachfolger von OLELIB<\/b><\/h2>\n
Zum Glück gibt es Typbibliotheken, die diesem Umstand abhelfen. Der Microsoft MVP<\/b> für Visual Basic 6<\/b>, Eduardo Morcillo<\/b>, stellte einst die geniale Bibliothek olelib.tlb<\/b> bereit, die in großem Umfang COM<\/b>-Schnittstellen von Windows-Komponenten definiert. Mit dieser können Dinge erreicht werden, die sich auch mit Unmengen von API<\/b>-Funktionen nicht realisieren lassen. Das Problem mit dieser Bibliothek aus dem Jahre 2003 ist, dass sie ziemlich ins Alter gekommen ist. Sie kann nur abbilden, was bis zu diesem Zeitpunkt bekannt war – und das sind maximal die Schnittstellen von Windows XP<\/b>.<\/p>\n
Das fiel auch anderen Programmierern auf. Es gibt immer noch rastlose Geister, die das altehrwürdige VB6<\/b>, auf dessen Stand das Pendant VBA<\/b> nun mal leider stehenblieb, weiterentwickeln. Viele kompetente Mitstreiter finden sich im Forums vbforums.com<\/b>. Der User fafalone<\/b> hat sich an die Arbeit gemacht, die olelib<\/b> mit neuem Leben zu füllen, und in die abgeleitete neue Bibliothek oleexp.tlb<\/b> Schnittstellendefinitionen eingebracht, die bis Windows 7<\/b> reichen. Und einer der Neuen ist das Interface zum ExplorerBrowser<\/b>.<\/p>\n
Es handelt sich, wohlgemerkt, nicht um eine aktive Komponente! Eine tlb<\/b> ist lediglich eine Typbibliothek, die sich auf aktive Komponenten bezieht. Es ist deshalb in Ihrem Unternehmen nicht zu befürchten, dass sie bei der Rasterfahndung nach gefährdenden Komponenten durchfällt, wie manche andere ActiveX-Dateien. Sie können sie getrost in die Verweise Ihrer Datenbank laden, wozu sie noch nicht einmal zwingend registriert werden muss. Die Methode References.LoadFromFile<\/b> erlaubt auch die Integration zur Laufzeit.<\/p>\nRegistrieren der OLEEXP<\/h2>\n
Freilich ist es dennoch sinnvoll, die Bibliothek im System zu registrieren, damit sie in Zukunft auch für andere VBA-Projekte zur Verfügung steht. Im Verzeichnis zur Beispieldatenbank explorerctl.accdb <\/b>finden Sie neben der oleexp.tlb<\/b> noch die ausführbare Datei regtlibv12.exe<\/b>, die solche Typbibliotheken registrieren kann. Das ist ein Kommandozeilen-Tool von Microsoft, das Sie wahrscheinlich auch auf Ihrem System als Bestandteil des NET-Frameworks 4<\/b> vorfinden. Der Einfachheit halber haben wir die Datei in das Verzeichnis der Datenbank kopiert.<\/p>\n
Damit Sie nicht umständlich in der Windows-Kommandozeile herumhantieren müssen, ruft eine weitere Datei register_tlb.bat<\/b> die regtlibv12<\/b> auf und übergibt ihr als Parameter die oleexp.tlb<\/b>. Die Registrierung verlangt über die UAC<\/b> automatisch nach erhöhten Rechten. Die Registrierung der Bibliothek erfolgt danach ganz im Stillen. Nach diesem Vorgang können Sie die Bibliothek über die Verweise von VBA und den Eintrag oleexp – olelib with modern interfaces by fafalone <\/b>in Ihr Projekt laden.<\/p>\nDie Klasse ExplorerBrowser<\/h2>\n
Im VBA-Objektkatalog stellen Sie links oben die Bibliothek oleexp<\/b> ein und navigieren danach zur Klasse ExplorerBrowser<\/b>. Der Objektkatalog gibt leider keine Auskunft darüber, ob eine Klasse instanzierbar ist oder lediglich eine Interface-Definition darstellt. Sie behelfen sich damit, dass Sie das Schlüsselwort New<\/b> ins VBA-Direktfenster schreiben und die gewünschte Bibliothek anfügen. Etwa so:<\/p>\n Sobald Sie den Punkt anfügen, zeigt Intellisense<\/b> alle Klassen an, die in der Library<\/b> instanzierbar sind. Beim ExplorerBrowser<\/b> ist das tatsächlich der Fall. Eine Instanz kann also per New<\/b>-Operator erzeugt werden, und die sonst häufig benötigten API-Aufrufe mit CoCreateInstance<\/b> et cetera entfallen. Bild 1 zeigt die recht überschaubaren und dennoch mächtigen Methoden der Klasse, auf die wir im Einzelnen noch zu sprechen kommen.<\/p>\n Bild 1: Die Klasse ExplorerBrowser und ihre Methoden im VBA-Objektkatalog<\/span><\/b><\/p>\n Sie erzeugen den Explorer im Formular also, indem Sie eine modulweit gültige Objektvariable deklarieren und ihr eine neue Instanz der Klasse zuweisen:<\/p>\n Damit tut sich indessen noch nichts. Erst müssen noch einige Methoden des Objekts aufgerufen werden, die grundlegende Einstellungen anweisen. Die wichtigste davon ist die Initialize<\/b>-Methode, welche dem Objekt unter anderem sagt, wo der Explorer zu platzieren ist. Dazu gleich mehr. Davor zeigt Ihnen aber Bild 2, wie das Resultat aussieht. Auf der linken Seite findet sich der Verzeichnisbaum mit allen Elementen. Nicht nur das Dateisystem ist vorhanden, sondern etwa auch Netzlaufwerke, Bibliotheken und die Systemsteuerung! Rechts zeigen sich die Elemente des Verzeichnisses. Die Spaltenköpfe können auf gleiche Weise manipuliert werden, wie sonst auch. Der Toolbar oben enthält dieselben Elemente, wie der Windows Explorer<\/b>. Die Ansicht und das Layout können also darüber gesteuert werden. Selbstverständlich funktionieren auch Drag And Drop<\/b> und alle Kontextmenüs samt gegebenenfalls installierten Shell Extensions<\/b>.<\/p>\n Bild 2: Im Formular fmExplorerSimple ist nur ein Windows Control im Detailbereich untergebracht, welches den Explorer abbildet<\/span><\/b><\/p>\n Ein Blick in die Entwurfsansicht des Formulars (s. Bild 3) verblüfft möglicherweise etwas. Hier finden Sie tatsächlich kein einziges Steuerelement, sondern nur den Detailbereich vor. Es ist Aufgabe der Initialize<\/b>-Methode, auf dem Detailbereich das ExplorerBrowser Control<\/b> zu rendern.<\/p>\n Bild 3: Die Entwurfsansicht des Formulars frmExplorerSimple stellt sich in der Tat äußerst simpel dar<\/span><\/b><\/p>\n Die Initialize<\/b>-Funktion hat folgende Syntax:<\/p>\n Der Aufruf dieser einen Funktion führt schon zur Anzeige des Explorers im Formular – wenn denn die Parameter korrekt übergeben werden.<\/p>\n Das wäre zunächst das Fenster-Handle<\/b> hwnd<\/b>, das angibt, auf welchem Fenster das Control angebracht werden soll. Der Typ RECT<\/b> für die Variable rct<\/b> ist ebenfalls in der oleexp<\/b>-Bibliothek definiert und steuert die Positionierung des Controls:<\/p>\n Left<\/b> ist der horizontale Abstand zum linken Rand des Host-Fensters, Top<\/b> der vertikale zum oberen Rand. Die Breite und Höhe des Controls ergeben sich aus Right<\/b> und Bottom<\/b>. Ist Left<\/b> etwa 20<\/b> und Right<\/b> 300<\/b>, so wird die Breite des Controls 280<\/b> sein. Mit 30<\/b> für Top<\/b> und 200<\/b> für Bottom<\/b> entsteht eine Höhe von 170. Alle Angaben in Pixel.<\/p>\n Der letzte Parameter pfs<\/b> muss eine Variable vom Typ oleexp.FOLDERSETTINGS <\/b>sein. Der Typ setzt zwei Enumerationskonstanten zusammen:<\/p>\n FOLDERFLAGS<\/b> und FOLDERVIEWMODE<\/b> sind Konstanten, die über den Or<\/b>-Operator zusammengesetzt werden können. Beispiel:<\/p>\n Damit stellt das Control die Dateien dann einerseits auf Links angeordnet<\/b> ein und verbietet die Web-Ansicht (fFlags<\/b>), andererseits wird die Detail- beziehungsweise Report-Ansicht angeordnet (ViewMode<\/b>). FVM_SMALLICON<\/b> etwa würde zur Ansicht Kleine Symbole<\/b> führen, FVM_THUMBNAIL<\/b> zu Große Symbole<\/b>.<\/p>\n Schon beim Initialisieren können also grundlegende Eigenschaften des Controls gesetzt werden.<\/p>\n Kopfzerbrechen bereitet indessen das benötigte Fenster-Handle<\/b> hwnd<\/b>. Zwar weist auch das Access<\/b>.Form<\/b>-Objekt eine Eigenschaft hwnd<\/b> auf, doch dieses Handle<\/b> bezieht sich auf das gesamte Fenster, nicht aber auf einen Formularbereich, wie den Detailbereich. Dieser, wie auch Formularkopf oder Formularfuß, sind tatsächlich eigene Fenster, die als Kindfenster des Hauptfensters fungieren. Zwar kann einer dieser Bereiche über die Section<\/b>-Funktion des Formulars ermittelt werden (Form.Section (acDetail)<\/b> etwa), doch dieses zurückgegebene Section<\/b>-Objekt kennt kein Fenster-Handle. Wir kommen hier nicht umhin, API<\/b>-Funktionen zu bemühen. Zum Glück ist der Code hierfür nicht sonderlich kompliziert. Listing 1 zeigt eine Hilfsroutine, die bei uns zum Einsatz kommt.<\/p>\n Listing 1: Hilfsfunktion mit API zum Ermitteln des Fenster-Handles des Detailbereichs eines Formulars<\/span><\/b><\/p>\n Sie geht vom Handle des Hauptfensters (Me.hwnd<\/b>) aus und befragt dann dessen Kindfenster mit der API-Funktion GetWindow<\/b>. Dazu gehören allerdings nicht nur die Bereiche des Formulars, sondern etwa auch andere Fensterelemente, wie die Navigationsleiste. Die Bereiche lassen sich aber dadurch identifizieren, dass sie alle den Fensterklassennamen OFormSub<\/b> tragen, den die Funktion GetClassName<\/b> zurückgibt. Grundsätzlich sind sowohl Formularkopf wie -fuß vorhanden. Sind diese ausgeblendet, so existieren die Fenster zwar, haben jedoch die Höhe 0<\/b>. Das zweite Kindfenster ist also immer der Detailbereich. Die Schleife identifiziert den Klassennamen und bricht ab, wenn der korrekte Name gefunden wurde. Da dann bereits das nächste Kindfenster über GetWindow<\/b> mit GW_HWNDNEXT<\/b> enumeriert wurde, steht in hwnd<\/b> das richtige Handle, welches als Rückgabewert der Funktion dient.<\/p>\n Damit haben wir bereits alle nötigen Bestandteile beisammen, um das Formular mit eingebettetem Explorer zum Laufen zu bringen. Den Code des Beispielformulars mit dem kleinsten Aufwand (frmExplorerMinimal<\/b>) demonstriert Listing 2. Die ganze Instanzierung des Explorer Controls findet im Ereignis Form_Load<\/b> statt.<\/p>\n Listing 2: Der komplette Inhalt des Formulars frmExplorerMinimal<\/span><\/b><\/p>\n Erst werden die zwei Teile der FOLDERSETTINGS<\/b>-Variablen pfs<\/b> mit Vorgabewerten bestückt. Selbst das könnte im Prinzip entfallen, da beide dann eben den Wert 0<\/b> enthielten. Zwar gibt es eigentlich keine von Microsoft deklarierte ViewMode<\/b>-Konstante, die diesem Wert entspricht, ein Fehler ereignet sich dabei aber nicht. Die Ansicht stellt sich bei Auskommentieren der beiden Zeilen einfach auf Große Symbole<\/b> ein. Die Flags<\/b>-Konstanten sind ohnehin alle optional.<\/p>\n Das Setzen der Abmessungen des Controls über die RECT<\/b>-Variable rct<\/b> allerdings ist zwingend erforderlich. Für Left<\/b> und Right<\/b> bleibt es bei 0<\/b>, was das Control in der linken oberen Ecke des Detailbereichs anordnet. Die Höhe in Bottom ergibt sich aus der Höhe des Detailbereichs (Section acDetail<\/b>), wobei der Wert durch Division mit 15<\/b> von Twips<\/b> nach Pixel<\/b> umgewandelt wird. Die Breite des Controls ergibt sich aus der des Formulars selbst (InsideWidth<\/b>). Schließlich wird für die per New<\/b> erzeugte Instanz oExplBrowser<\/b> die Initialize<\/b>-Methode aufgerufen und das Fenster-Handle des Detailbereichs über die Hilfsfunktion GetDetailHwnd<\/b> (Listing 1) übergeben.<\/p>\n Nicht erwähnt haben wir bisher die Methode SetOptions<\/b> des ExplorerBrowser<\/b>-Objekts. Die hier anzugebenden Konstanten steuern das Gesamtlayout des Controls. Wichtig etwa ist das Setzen von EBO_SHOWFRAMES<\/b>. Erst diese Zuweisung sagt dem Control, dass es den Explorer komplett nachbilden soll, und Treeview sowie Toolbar anzeigen soll. Unterbleibt das, so zeigt es lediglich die Dateiansicht an, wie in Bild 4. Für diese gibt es sicher ebenfalls Anwendungsfälle.<\/p>\n Bild 4: Ist EBO_SHOWFRAMES nicht gesetzt, so zeigt das Control nur den rechten Teil des Explorers<\/span><\/b><\/p>\n Unterschlagen haben wir auch, dass das Control erst wissen muss, welches Verzeichnis des Systems es überhaupt anzeigen soll. Dies übernimmt seine Methode BrowseToIDList<\/b>. Lässt man sie weg, so zeigt das Control nur eine weiße Fläche.<\/p>\n Die Methode erwartet eine sogenannte ID-List<\/b>. Das ist in der Shell<\/b>-Welt im Grunde eine eindeutige ID<\/b> eines Verzeichnisses oder einer Datei. Einen String für einen Verzeichnispfad kann man hier nicht angeben, sondern müsste diesen erst über eine Hilfsfunktion in eine ID<\/b> umwandeln. Das erläutern wir später. Die andere hier verwendete Option ist das Ermitteln einer ID<\/b> für einen der Standardordner von Windows über die API-Funktion SHGetSpecialFolderLocation<\/b>. Ihr übergibt man die Konstante eines der Standardordner, wobei CLSID_DESKTOP<\/b> den Desktop symbolisiert. Möchten Sie zu den Laufwerken navigieren, wie in Bild 4, so geben Sie stattdessen die Konstante CLSID_DRIVES<\/b> an. Die möglichen Konstanten sehen Sie im Objektkatalog zur Bibliothek oleexp<\/b> unter der Liste CSIDLs<\/b> ein.<\/p>\n Die ermittelte ID<\/b> speichert die formularglobale Variable lPIDL<\/b>. Sie wird BrowseToIDList<\/b> übergeben. Der zweite Parameter SBSP_ABSOLUTE<\/b> sagt ihr zusätzlich, dass ein absoluter Sprung zum Ordner erfolgen soll. Möglich wäre auch ein relativer Sprung, den wir hier aber nicht erklären, weil dies zu deutlich höherem Aufwand führen würde.<\/p>\n Mehr gibt es nicht zu tun. Die gerade 40 Zeilen des Formularcodes zeigen, wie einfach ein Explorer anzulegen ist. Beim Schließen des Formulars (Form_Unload<\/b>) muss allerdings der Explorer wieder abgebaut werden, damit es nicht zu Speicherlecks oder Abstürzen kommt. Die Destroy<\/b>-Methode veranlasst dies. Außerdem sollte die erhaltene Ordner-ID in lPIDL<\/b> noch freigegeben werden, was über die API-Funktion CoTaskMemFree<\/b> geschieht. Wir haben damit nun einen funktionsfähigen Explorer im Formular. Wünschenswert wäre allerdings noch eine erweiterte Einflussnahme auf seine Gestalt und sein Verhalten, wie auch zusätzlich Interaktion mit dem Control und den angezeigten Ordnern und Dateien. Die aufgebohrte Version mit allerlei Zusatz-Features nennt sich in der Beispieldatenbank frmExplorerCtl<\/b>.<\/p>\n Bild 5 zeigt dieses Formular zur Laufzeit. Beschreiben wir kurz seine Funktionalität. Alle Bezeichnungen sind in Englisch gehalten, damit der Bezug zu den Methoden im VBA-Code etwas deutlicher wird.<\/p>\n Bild 5: Im Formular frmExplorerCtl können unten verschiedene Einstellungen des Explorer Controls zur Laufzeit vorgenommen werden<\/span><\/b><\/p>\n Zunächst sind im Formular auch Kopf und Fuß angezeigt. Das Explorer Control befindet sich ausfüllend im Detailbereich. Im Formularkopf bewirkt ein Klick auf die Schaltfläche Reset to ““Computer““<\/b> den Sprung zu eben diesem Spezialordner, also der Laufwerksübersicht. Haben Sie sich im Explorer durch diverse Verzeichnisse gehangelt, so gelangen Sie über den Button Back<\/b> zum vorigen Verzeichnis, mit Forward<\/b> zum nächsten, so wie bei der Navigation im richtigen Explorer auch. Dir Up<\/b> schaltet eine Verzeichnisebene aufwärts, falls möglich. Beim Desktop klappt das natürlich nicht. Die Textbox oben rechts zeigt das aktuelle Verzeichnis an. Dies entspricht der Adresszeile des Explorers. Eine Eingabe ist hier allerdings nicht möglich. Bei speziellen Elementen, wie denen der Systemsteuerung etwa, bleibt die Textbox leer.<\/p>\n Rechts unten gibt es eine mehrzeilige Textbox, die der Ausgabe von durch das Control ausgelösten Ereignissen dient wie auch der weiterer Informationen. In der Abbildung ist zu erkennen, dass etwa die Navigation zu Verzeichnissen abgefangen werden kann. Auch die Markierung von Dateien bleibt dem Formularcode nicht verborgen.<\/p>\n Im linken Bereich des Formularfußes können über zahlreiche Checkboxen und Optionsfelder Einstellungen für das Control vorgenommen werden. Diese beziehen sich allerdings alle auf die Dateiansicht im rechten Rahmen, der sogenannten Folder View<\/b>. Dabei können Sie mit einem Klick auf die Schaltfläche Get<\/b> die momentane Konfiguration der Folder View<\/b> ermitteln. Die Checkboxen werden dann gemäß der Ansicht markiert. ändern Sie einzelne Markierungen, so wirken sich die neuen Einstellungen erst nach Klick auf den roten Button Apply view settings<\/b> aus. <\/p>\n In der Mitte des Formularfußes schließlich können Sie über die vier blauen Schaltflächen verschiedene Aktionen auslösen, die lediglich als Beispiele die Steuerungsmöglichkeiten des Controls demonstrieren sollen. Edit 5th item<\/b> etwa markiert das fünfte Element von oben in der Dateiansicht und bringt es in editierbaren Zustand, sodass Sie dessen Namen ändern können. Es spielt dabei keine Rolle, ob es sich um eine Datei oder ein Verzeichnis handelt.<\/p>\n Select items with ““P*““<\/b> markiert alle Elemente in der Ansicht, die mit dem Buchstaben P<\/b> beginnen. Search for ““*.pdf““<\/b> stößt eine Suche nach allen Elementen Im Verzeichnis und seinen Unterverzeichnissen an, die PDF-Dokumente darstellen. Dabei bildet sich eine neue View<\/b> mit den Suchergebnissen. Circle Items <\/b>markiert visuell alle Elemente in der Ansicht der Reihe nach von oben nach unten mit einem Intervall von 80 Millisekunden. Sort By File Size DESC <\/b>sortiert die Ansicht der Dateien nach deren Dateigröße absteigend, also nach der Spalte Größe<\/b>.<\/p>\n Die Optionsfelder dienen der Einstellung des Ansichtsmodus. Report view <\/b>etwa zeigt die Detailansicht, Small icons<\/b> zeigt Kleine Symbole<\/b>, Thumbnail view<\/b> Miniaturabbilder. Diese Einstellung können Sie ja auch manuell über den Toolbar des Controls vornehmen. Bei allen Optionen für eine Symboldarstellung aktiviert sich zusätzlich rechts das Kombinationsfeld Icon Size<\/b>. über dieses können Sie dann außerdem die quadratische Größe der Symbol-Icons bestimmen. Erlaubt sind hier Angaben von 16×16<\/b> bis 256×256<\/b>. <\/p>\n Ganz in der Mitte befindet sich eine kleine Textbox mit der überschrift Sort String<\/b>. Hier zeigt sich nach Klick auf den Get<\/b>-Button die aktuelle Sortierung der View<\/b>, wie das Control sie intern ausgibt. Sie beginnt immer mit dem Präfix prop:<\/b>. Sind die Elemente nach Namen sortiert, so nennt sich die Sortierspalte System.ItemsNameDisplay<\/b>. Sie können diesen String auch modifizieren! Geben Sie etwa System.ModifiedDate<\/b> an, so sortiert sich die Ansicht nach dem änderungsdatum der Elemente, nachdem Sie auf den Apply<\/b>-Button klicken. Eine absteigende Sortierung erreichen Sie übrigens, indem Sie nach prop:<\/b> ein Minuszeichen einsetzen.<\/p>\n Zu erläutern wäre schließlich noch die Checkbox Allow file drop<\/b> unten. Ist sie aktiviert, so können Sie von außerhalb des Formulars Dateien oder Verzeichnisse in die View ziehen und lösen damit den normalen Kopier-, Verschiebe- oder Verknüpfungsvorgang aus. Ist sie deaktiviert, so werden diese Aktionen unterbunden. Allerdings taucht dann trotzdem zur Information eine Messagebox auf, die den oder die Namen der gedragten <\/b>Elemente ausgibt.<\/p>\n Trotz der zahlreichen Features des Formulars beschränkt sich sein Code auf circa 360 überschaubare Zeilen, von denen etliche Kommentare enthalten.<\/p>\n Was noch auf unserer ToDo-Liste steht gleich vorneweg: Es ist uns nicht gelungen, einzelne Bereiche des Controls ein- und auszuschalten. über SetOptions<\/b> (s. Listing 2) und EBO_SHOWFRAMES<\/b> kann bisher nur die Sichtbarkeit des Treeviews des Controls gesteuert werden. Den Toolbar ausschalten klappt indessen nicht. Zwar sieht Microsoft diese Möglichkeit im Prinzip vor, der dazu benötigte Umgang mit speziellen Interfaces und einer Callback-Funktion überfordert VBA – oder uns – jedoch etwas. Zusammengefasst kann mit dem Control in vielerlei Hinsicht über VBA interagiert werden. Schauen wir uns im Folgenden an, wie die Programmierung der einzelnen Features gelingt.<\/p>\n Für einige Aufgaben benötigen wir einen Bezug auf Klassenobjekte, die in der Bibliothek OLEEXP<\/b> nicht vorhanden sind. Das sind vornehmlich Objekte der Windows Shell <\/b>und deren Interfaces<\/b>. Man findet sie aber alle in Komponenten von Windows. Alle hier aufgeführten Bibliotheken sind Bestandteil von Windows und brauchen deshalb nicht registriert zu werden. Bild 6 zeigt diese Libraries<\/b> im Verweise-Dialog des Projekts.<\/p>\n Bild 6: Alle Verweise des Datenbank-VBA-Projekts stammen mit Ausnahme der Bibliothek OLEEXP aus gängigen Windows- und Office-Komponenten<\/span><\/b><\/p>\n Elementar ist die Bibliothek Microsoft Shell Controls And Automation<\/b>, welche sich in der Systemdatei shell32.dll<\/b> befindet. Sie enthält einige Klassen, die auch vom Browser Control verwendet werden. Der Verweis auf die Microsoft Forms 2.0 Object Library<\/b> wäre an sich nicht erforderlich. Er lässt sich jedoch über den normalen Verweise-Dialog<\/b> eigenartigerweise nicht mehr entfernen, nachdem er einmal gesetzt wurde. Den Verweis auf die OLEEXP<\/b>-Bibliothek erläuterten wir ja bereits.<\/p>\n <\/p>\n Der Initialize<\/b>-Methode des ExplorerBrowser<\/b>-Objekts gibt man über den RECT<\/b>-Parameter mit, wie groß die Ausdehnung des Controls im Formularfenster ausfallen soll. Man ist auf diese jedoch nicht festgelegt. Auch zur Laufzeit können Sie über die Methode SetRect<\/b> eine andere Größe anweisen. Das ist praktisch, um das Control immer auf die Größe des Detailbereichs zu bringen, wenn das Formular verändert wird. Also setzen Sie in das Ereignis Bei Größenänderung<\/b> des Formulars etwa den Code aus Listing 3.<\/p>\n Listing 3: Das Control macht hiermit Größenänderungen mit<\/span><\/b><\/p>\n Zur Sicherheit wird hier abgefragt, ob das Browser Control überhaupt erzeugt wurde. Dann ist der Inhalt der zuständigen Objektvariablen oExplBrowser<\/b> nicht Nothing<\/b>. Anschließend ermittelt die API-Funktion GetWindowRect<\/b> abermals die Ausdehnung des Detailbereichs über dessen Fenster-Handle, welches Sie über die schon erwähnte Hilfsfunktion GetDetailHwnd<\/b> bekommen. Die Höhe wird in der Variablen y<\/b> gespeichert. Die Breite könnte eigentlich ebenfalls aus dem RECT<\/b>-Typ rct<\/b> ausgelesen werden; wir nehmen hier jedoch die Breite des Formulars selbst in InsideWidth<\/b>. SetRect<\/b> erwartet dann als ersten Parameter ein Pseudo-Handle<\/b>, das wir unbeachtet lassen, und deshalb 0<\/b> zuweisen. Die nächsten beiden Parameter geben die linke obere Ecke des Controls im Detailbereich an, also dessen x- und y-Koordinaten. Auch hier verwenden wir 0<\/b>. Dann folgen Breite und Höhe des Controls, die in den Variablen x und y gespeichert sind. Damit macht das Control alle Größenänderungen des Formulars mit, so als wäre es mit dem Verankern<\/b>-Feature von Access ausgestattet.<\/p>\n Wie Sie aus dem Objektkatalog (Bild 1) ablesen können, löst das ExplorerBrowser<\/b>-Objekt selbst keine Ereignisse aus. Dafür ist nämlich ein separates Interface<\/b> namens IExplorerBrowserEvents<\/b> zuständig (Bild 7). Und Sie müssen dem Objekt erst mitteilen, wo sich dieses Interface<\/b> befindet. Wie aber kann eine Instanz dieser Interface<\/b>-Klasse angelegt werden<\/p>\n Bild 7: Die Klasse IExplorerBrowserEvents im VBA-Objektkatalog<\/span><\/b><\/p>\n Hier kommt das selten genutzte Schlüsselwort Implements<\/b> von VBA ins Spiel. In den Kopf des Moduls schreiben Sie das:<\/p>\n Beim Kompilieren weist VBA Sie nun per Fehler darauf hin, dass die Methoden dieser Schnittstelle im Modul eingebaut sein müssen. Sie suchen also in der linken oberen Combo des Modulfensters den Eintrag IExplorer-BrowserEvents<\/b> heraus, worauf Sie in der rechten die einzelnen Methoden der Schnittstellen auswählen können. VBA legt dabei automatisch die zugehörigen Prozeduren an, ähnlich wie bei den Ereignissen einer Objektvariablen. Damit ist in der Formularklasse zusätzlich das Interface IExplorerBrowserEvents<\/b> integriert. Es muss nur noch eine Verbindung zwischen Control und der Formularklasse hergestellt werden. Das übernimmt die Methode Advise<\/b> des ExplorerBrowsers<\/b>:<\/p>\n Der Methode Advise<\/b> wird das Objekt übergeben, welches die Schnittstelle IExplorerBrowserEvents<\/b> implementiert – hier das Formularobjekt durch Me<\/b> -, sowie eine Variable, welche eine ID<\/b> für die Verbindung entgegennimmt.<\/p>\n Sie wird noch benötigt und ist deshalb im Modulkopf als Variable lEventCookie<\/b> vom Typ Long<\/b> deklariert. Beim Entladen des Formulars sollte diese Verbindung wieder getrennt werden. Das wiederum geschieht über die Methode UnAdvise<\/b> des Exlorer-Browsers<\/b>:<\/p>\n Es gibt also vier Ereignisse, die das Control selbst auslösen kann. OnNavigationPending<\/b> passiert bei Anwahl eines Verzeichnisses im Treeview des Controls. Es besagt, dass die Navigation zum ihm noch aussteht. Der gewählte Ordner wird dabei durch den Parameter pidlFolder<\/b> übergeben.<\/p>\n Er kann dann mithilfe einer API-Funktion in einen Verzeichnis-String umgewandelt werden:<\/p>\n SHGetPathFromIDListW<\/b> ist hier für die Umwandlung zuständig. Die API-Funktion ist im Kopf des Formularmoduls definiert. Im Beispiel sähe die Verwendung der Hilfsfunktion etwa so aus:<\/p>\n Sobald Sie ein Verzeichnis im Control auswählen, wird dessen Pfad nun im VBA-Direktfenster ausgegeben. Im Beispielformular allerdings protokolliert die Prozedur AddToLog<\/b> das Ereignis in der entsprechenden Textbox.<\/p>\n Das Control muss nun die Folder View<\/b>, also die rechte Ansicht des Explorers, erzeugen. Ist das von Erfolg gekrönt, so tritt das Ereignis OnViewCreated <\/b>auf den Plan. Als Parameter übergibt es eine Interface-Variable psv<\/b> des Typs IShellView<\/b>.<\/p>\n Diese Schnittstelle ist ebenfalls in der Bibliothek OLEEXP <\/b>definiert. Man benötigt einen Verweis auf diese Schnittstelle, um später an die Elemente der Datei-und Ordnerliste heranzukommen. Deshalb wird in der Demo ein Verweis auf sie in der Formularvariablen IShView <\/b>abgelegt:<\/p>\n Es kann sein, dass die Navigation zu einem Verzeichnis im Control fehlschlägt. Dies wäre etwa der Fall, wenn Sie eine ungültige ID-List<\/b> als Parameter an die Methode BrowserToIDList <\/b>übergeben. In diesem Fall ereignet sich OnNavigationFailed<\/b>.<\/p>\n Ist der ganze Vorgang abgeschlossen, also das Verzeichnis im Treeview markiert und die Folder View<\/b> dazu aufgebaut, so kommt es zum Ereignis NavigationComplete<\/b>, auch hier wieder unter Angabe des angezeigten Ordners in pidlFolder<\/b>.<\/p>\n über diese Ereignisse haben Sie also im Formularcode volle Kontrolle über die Verzeichnisse, zu denen im Control navigiert wird. Zugriff auf die Dateien und andere Elemente der Folder View<\/b> besteht indessen noch nicht. Der ExplorerBrowser<\/b> selbst enthält hierfür keinerlei Methoden. Die liefert erst die ShellView<\/b>, welche über das Ereignis OnViewCreated<\/b> zurückgeliefert und in der Variablen ShView<\/b> zwischengespeichert wurde. Und hier wird es leider kompliziert, denn das Interface IShellView<\/b> löst selbst wiederum keine Ereignisse aus. Es sind einige Tricks vonnöten, um aus der Schnittstelle ein neues Objekt abzuleiten, welches Ereignisse unterstützt.<\/p>\n Und das ist die Klasse ShellFolderView<\/b> der Bibliothek Shell32<\/b>, die wir in die Verweise des VBA-Projekts aufnahmen. Nehmen Sie sie im Objektkatalog unter die Lupe (Bild 8). Neben verschiedenen Properties oben, die vor allem das Layout der Elemente der View<\/b> bestimmen, gibt es fünf Methoden zu ihrer Steuerung und fünf Ereignisse, die ausgelöst werden, wenn Sie Aktionen auf die Elemente ausführen. Das kann das Markieren von Dateien oder Verzeichnissen sein (SelectionChanged<\/b>), das Ziehen von Elementen (BeginDrag<\/b>) oder eine Aktion durch Doppelklicken beziehungsweise über das Kontextmenü eines Elements (VerbInvoked<\/b>, DefaultVerbInvoked<\/b>). EnumDone<\/b> passiert dann, wenn alle Elemente eines Verzeichnisses vom Control ermittelt wurden, und hat damit lediglich informativen Charakter.<\/p>\n Bild 8: Die Klasse ShellFolderView der Shell32-Bibliothek zeigt ihre Methoden und Ereignisse im VBA-Objektkatalog<\/span><\/b><\/p>\n Am Interessantesten ist sicher das Ereignis SelectionChanged<\/b>. ändern Sie etwa die Markierung oder Auswahl von Dateien im Control, so kommt es immer zu diesem Ereignis. Es übergibt allerdings keinen Parameter, aus dem sich etwas über die Art der Auswahl ableiten ließe. Dafür wäre dann die Methode SelectedItems<\/b> zu bemühen, die eine Liste von FolderItems<\/b> zurückgibt. Dazu später mehr.<\/p>\n Die Frage ist nun, wie man über die vom Control im Ereignis OnViewCreated<\/b> erhaltene ShellView<\/b> zu diesem Objekt ShellFolderView<\/b> gelangt. Im Formularklassenmodul geschieht dies über die ausgelagerte Hilfsroutine ConnectToView<\/b>. Ihr Aufruf wird direkt im entsprechenden Ereignis OnViewCreated <\/b>vollzogen:<\/p>\n Den Code der Routine finden Sie etwas gekürzt in Listing 4. Die Funktion GetItemObject<\/b> der IShellView<\/b> wird aufgerufen und dabei als Ergebnis durch das Flag SVGIO_BACKGROUND<\/b> deren sogenanntes Dispatch<\/b>-Interface abgefragt. Eben das ist die ShellFolderView<\/b>, welche die Objektvariable oViewObj <\/b>entgegennimmt. Sie ist im Modul oben deklariert:<\/p>\n Listing 4: Erhalten des ShellFolderView-Objekts oViewObj<\/span><\/b><\/p>\n Dieses Objekt löst leider noch keine Ereignisse aus, weil es ohne die Anweisung WithEvents<\/b> deklariert ist. Fügten Sie diese ein, so passierte trotzdem nichts und die Ereignisse unterblieben. Grund dafür ist, dass die Verbindung zur Ereignisschnittstelle für die ShellView<\/b> noch nicht hergestellt ist. Wir fanden aber eine geniale API-Funktion unter Windows, die diese Verbindung herstellen kann: ConnectToConnectionPoint<\/b>. Ihr übergeben Sie die Formularklasse (Me<\/b>) und die gewünschte Event-Schnittstelle New<\/span> oleexp.<\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2017_04\/OBK_ExplBrowser.png\")
<\/p>\nDim <\/span>oExplBrowser As <\/span>oleexp.ExplorerBrowser\r\nPrivate Sub <\/span>Form_Load()\r\nSet<\/span> oExplBrowser = New<\/span> oleexp.ExplorerBrowser\r\n...<\/pre>\n![\"Im](\"..\/fileadmin\/_temp_\/2017_04\/frmExplorerSimple_RT.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2017_04\/frmExplorerSimple_DS.png\")
<\/p>\nInitialisieren des ExplorerBrowsers<\/h2>\n
Initialize (hwnd As Long<\/span>, rct As <\/span>RECT, pfs As <\/span>FOLDERSETTINGS) As Long<\/span><\/pre>\nType RECT\r\n Bottom As Long<\/span>\r\n Left As Long<\/span>\r\n Right As Long<\/span>\r\n Top As Long<\/span>\r\nEnd Type<\/pre>\nType FOLDERSETTINGS\r\n fFlags As <\/span>FOLDERFLAGS\r\n ViewMode As <\/span>FOLDERVIEWMODE\r\nEnd Type<\/pre>\nDim <\/span>pfs As <\/span>oleexp.FOLDERSETTINGS\r\npfs.fFlags = FWF_ALIGNLEFT Or FWF_NOWEBVIEW\r\npfs.ViewMode = FVM_DETAILS<\/pre>\nPrivate <\/span>Const GW_CHILD As Long<\/span> = 5\r\nPrivate <\/span>Const GW_HWNDNEXT As Long<\/span> = 2 \r\nPrivate <\/span>Declare Function GetClassName Lib \"user32.dll\" Alias \"GetClassNameA\" (ByVal hwnd As Long<\/span>, _\r\n ByVal lpClassName As String<\/span>, ByVal nMaxCount As Long<\/span>) As Long<\/span>\r\nPrivate <\/span>Declare Function GetWindow Lib \"user32.dll\" (ByVal hwnd As Long<\/span>, ByVal wCmd As Long<\/span>) As Long<\/span> \r\nPrivate Function <\/span>GetDetailHwnd() As Long<\/span>\r\n Dim <\/span>hwnd As Long<\/span>\r\n Dim <\/span>ret As Long<\/span>\r\n Dim <\/span>rct As <\/span>RECT\r\n Dim <\/span>sClass As String<\/span>\r\n \r\n hwnd = GetWindow(Me.hwnd, GW_CHILD)\r\n Do\r\n sClass = String(255, 0)\r\n ret = GetClassName(hwnd, sClass, 255)\r\n sClass = Left<\/span>(sClass, ret)\r\n hwnd = GetWindow(hwnd, GW_HWNDNEXT)\r\n Loop<\/span> Until sClass = \"OFormSub\"\r\n GetDetailHwnd = hwnd\r\nEnd Function<\/span><\/pre>\nPrivate <\/span>oExplBrowser As <\/span>oleexp.ExplorerBrowser\r\nPrivate <\/span>lPIDL As Long<\/span>, hwndDetail As Long<\/span>\r\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>rct As <\/span>oleexp.RECT\r\n Dim <\/span>pfs As <\/span>oleexp.FOLDERSETTINGS\r\n \r\n pfs.fFlags = FWF_ALIGNLEFT Or FWF_NOWEBVIEW\r\n pfs.ViewMode = FVM_DETAILS\r\n rct.Bottom = Me.Section(acDetail).Height \\ 15\r\n rct.Right<\/span> = Me.InsideWidth \\ 15\r\n Set<\/span> oExplBrowser = New<\/span> oleexp.ExplorerBrowser\r\n oExplBrowser.Initialize GetDetailHwnd, rct, pfs\r\n oExplBrowser.SetOptions EBO_SHOWFRAMES\r\n lPIDL = SHGetSpecialFolderLocation(ByVal 0&, _\r\n CSIDL_DESKTOP)\r\n oExplBrowser.BrowseToIDList lPIDL, SBSP_ABSOLUTE\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_Unload(Cancel As Integer<\/span>)\r\n oExplBrowser.Destroy\r\n oleexp.CoTaskMemFree lPIDL\r\nEnd Sub<\/span>\r\n(Zur <b>Hilfsfunktion GetDetailHwnd siehe Listing 1)<\/pre>\n![\"Ist](\"..\/fileadmin\/_temp_\/2017_04\/frmMinimal_NoFrames.png\")
<\/p>\nDas Ultra-Komplettbeispiel<\/h2>\n
![\"Im](\"..\/fileadmin\/_temp_\/2017_04\/frmExplorerCtl_RT.png\")
<\/p>\nVerweise des VBA-Projekts<\/h2>\n
![\"Alle](\"..\/fileadmin\/_temp_\/2017_04\/References.png\")
<\/p>\nBrowser Control resizen<\/h2>\n
Private Sub <\/span>Form_Resize()\r\n Dim <\/span>x As Long<\/span>, y As Long<\/span>\r\n Dim <\/span>rct As <\/span>RECT\r\n \r\n If <\/span>oExplBrowser Is Nothing Then<\/span> Exit Sub<\/span>\r\n \r\n GetWindowRect GetDetailHwnd, rct\r\n y = rct.Bottom - rct.Top\r\n x = Me.InsideWidth \\ 15\r\n oExplBrowser.SetRect 0, 0, 0, x, y\r\nEnd Sub<\/span><\/pre>\nEreignisse abfangen<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2017_04\/OBK_BrowserEvents.png\")
<\/p>\nImplements IExplorerBrowserEvents<\/pre>\n
Implements IExplorerBrowserEvents\r\nPrivate <\/span>lEventCookie As Long<\/span>\r\nPrivate Sub <\/span>Form_Load()\r\n ...\r\n oExplBrowser.Advise Me, lEventCookie\r\n ...\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>IExplorerBrowserEvents_OnNavigationPending _\r\n (ByVal pidlFolder As Long<\/span>)\r\n''''...\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>IExplorerBrowserEvents_OnNavigationComplete _\r\n (ByVal pidlFolder As Long<\/span>)\r\nPrivate Sub <\/span>IExplorerBrowserEvents_OnNavigationFailed _\r\n (ByVal pidlFolder As Long<\/span>)\r\nPrivate Sub <\/span>IExplorerBrowserEvents_OnViewCreated _\r\n (ByVal psv As <\/span>oleexp.IShellView)<\/pre>\nolExplBrowser. UnAdvise lEventCookie<\/pre>\n
Private Function <\/span>GetPathFromPidl(pidl As Long<\/span>) As String<\/span>\r\n Dim <\/span>pszPath As String<\/span>\r\n pszPath = String(MAX_PATH, 0)\r\n If <\/span>SHGetPathFromIDListW(pidl, StrPtr(pszPath)) Then<\/span>\r\n If <\/span>InStr<\/span>(pszPath, vbNullChar) Then<\/span>\r\n GetPathFromPidl = Left$(pszPath, InStr<\/span>(pszPath, vbNullChar) - 1)\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nPrivate Sub <\/span>IExplorerBrowserEvents_OnNavigationPending _\r\n (ByVal pidlFolder As Long<\/span>)\r\n Debug.Print<\/span> GetPathFromPidl( pidlFolder)\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>IShView As <\/span>oleexp.IShellView \r\nPrivate Sub <\/span>IExplorerBrowserEvents_OnViewCreated _\r\n (ByVal psv As <\/span>oleexp.IShellView)\r\n AddToLog \"View created\"\r\n Set<\/span> IShView = psv\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2017_04\/OB_ShellFolderView.png\")
<\/p>\nConnectToView<\/pre>\n
Private Sub <\/span>ConnectToView()\r\n DisconnectFromView\r\n \r\n IShView.GettemObject SVGIO_Flags.SVGIO_BACKGROUND, _\r\n IIDDispatch, oViewObj\r\n If <\/span>Not<\/span> oViewObj Is Nothing Then<\/span>\r\n If 0 = ConnectToConnectionPoint(Me, _\r\n IID_DShellFolderViewEvents, 1&, _\r\n oViewObj, lCookie, Nothing) Then\r\n Set<\/span> oViewDispatch = oViewObj\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>DisconnectFromView()\r\n If <\/span>Not<\/span> oViewObj Is Nothing Then<\/span>\r\n ConnectToConnectionPoint Nothing, _\r\n IID_DShellFolderViewEvents, _\r\n 0&, oViewObj, lCookie, Nothing\r\n Set<\/span> oViewDispatch = Nothing\r\n Set<\/span> oViewObj = Nothing\r\n lCookie = 0&\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>oViewObj As <\/span>Shell32.ShellFolderView<\/pre>\n