<\/p>\n
Für den einen oder anderen Anwendungsfall benötigen Sie einen Datei-öffnen-Dialog, um eine Datenbank auszuwählen. Dieser Dialog hat den Nachteil, dass er selten direkt die gewünschte Datenbank geschweige denn das Verzeichnis anzeigt. Wie wäre es also mit einem speziellen Dialog, der nur die Verzeichnisse einliest, die überhaupt Datenbankdateien enthalten, und diese in einem TreeView-Steuerelement zur Auswahl bereithält<\/b><\/p>\n
Ziel <\/b><\/p>\n
Das Ziel dieses Beitrags ist es, einen Dialog zu erstellen, der alle Datenbankdateien oder auch nur die in einem bestimmten Unterordner befindlichen anzeigt und zur Auswahl anbietet. Damit sollen die üblichen Dialoge ersetzt werden, die erstens immer alle Verzeichnisse und Dateien anzeigen und zweitens nie das Verzeichnis liefern, das man gerade benötigt. Für die Erstellung eines solchen Dialogs ist eine Menge Vorarbeit nötig – zum Beispiel müssen Sie eine Prozedur programmieren, die alle Verzeichnisse ab dem gewünschten Unterordner erfasst und nach Datenbankdateien durchsucht. Diese werden über die Dateiendung erkannt (.mdb<\/b>, .accdb <\/b>…). Der Dialog soll nur diejenigen Verzeichnisse anzeigen, die direkt oder in einem Unterverzeichnis mindestens eine Datenbankdatei enthalten. Bild 1 zeigt, wie der Dialog ungefähr aussehen soll. Sie erkennen hier ein Textfeld, in das Sie das beim Einlesen zu verwendende Startverzeichnis eintragen. Dieses lässt sich mit einem Mausklick auf die Schaltfläche rechts daneben auch per Verzeichnis auswählen<\/b>-Dialog einlesen. Ein Klick auf die Schaltfläche Einlesen <\/b>startet den Einlesevorgang, der je nach Umfang der einzulesenden Daten eine Weile dauern kann (auf meiner Festplatte, die zugegebenermaßen sehr viele Daten enthält, etwa acht Minuten – planen Sie also eine Kaffeepause für diesen Vorgang ein). Wenn Sie einmal ermittelt haben, wo sich die Datenbankdateien befinden, können Sie für den nächsten Einlesevorgang gegebenenfalls einen entsprechenden Unterordner als Startverzeichnis angeben, um Zeit zu sparen. Zu Beginn sollten Sie jedoch einmal die komplette Festplatte einlesen – ich fand es jedenfalls sehr interessant, an welchen Stellen überall Datenbankdateien gespeichert sind.<\/p>\n
![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2013_03\/DatenbankenAnzeigen-web-images\/pic003.png\")
<\/p>\n
Bild 1: Dialog zur Anzeige von Datenbankdateien<\/span><\/b><\/p>\n Die erfassten Daten werden in einer Tabelle gespeichert, die wir weiter unten vorstellen. Die Daten sollen dann in einem TreeView-Steuerelement angezeigt werden. Dazu liest die Anwendung die Daten der Tabelle aus und trägt sie in das TreeView-Steuerelement ein. Verzeichnisse und Datenbankdateien werden mit entsprechenden Symbolen gekennzeichnet. Vorerst soll das Formular lediglich beim Schließen den Pfad der aktuell ausgewählten Datenbankdatei zurückliefern.<\/p>\n Überlegungen<\/b><\/p>\n Schauen wir uns die Ausgangssituation an. Das Dateisystem enthält beliebig tief verschachtelte Verzeichnisstrukturen, von denen nicht alle Access-Dateien speichern. Das zu füllende TreeView-Steuerelement soll lediglich die Verzeichnisse anzeigen, in denen sich auch Access-Dateien befinden. Dazu müssen wir alle Verzeichnisse durchlaufen und diejenigen mit Access-Dateien ermitteln. Die Pfade der Verzeichnisse mit Access-Dateien sollen dann vom Laufwerksbuchstaben angefangen über die einzelnen Verzeichnisse im TreeView-Steuerelement abgebildet werden.<\/p>\n Wie erledigen wir dies am einfachsten, wie werden die Daten über die Verzeichnisse und Access-Datenbanken gespeichert, wie füllen wir das TreeView-Steuerelement und wie oft soll diese Prozedur wiederholt werden<\/p>\n Verzeichnisse und Dateien per FileSystemObject durchlaufen<\/b><\/p>\n Die Werkzeuge zum Einlesen der Verzeichnisse und Dateien liefert das FileSystemObject<\/b>. Es bietet Möglichkeiten, die Verzeichnisse rekursiv zu durchlaufen und die Dateien auf ihre Dateiendung hin zu untersuchen.<\/p>\n Informationen speichern<\/b><\/p>\n Die Tabelle zum Aufnehmen der Informationen muss folgende Felder enthalten und sieht, mit einigen Daten gefüllt, wie in Bild 2 aus:<\/p>\n Bild 2: Tabelle zum Speichern der Dateien und Verzeichnisse<\/span><\/b><\/p>\n Dateien einlesen und speichern<\/b><\/p>\n Warum verwenden wir in der Tabelle keinen Autowert für das Primärschlüsselfeld Normalerweise würden wir so vorgehen: Wir lesen das Root-Element ein, also beispielsweise das Verzeichnis c:\\ <\/b>und speichern es in der Tabelle. Dann arbeiten wir uns durch alle untergeordneten Verzeichnisse. Wenn c:\\ <\/b>nun mit dem Wert 1 <\/b>im Primärschlüsselfeld gespeichert wurde, würden wir für die untergeordneten Verzeichnisse beziehungsweise Einträge den Wert 1 <\/b>im Feld VerzeichnisID <\/b>eintragen. <\/p>\n Dazu müssen wir aber jedes Verzeichnis in der Tabelle anlegen – auch wenn wir feststellen, dass sich weder in diesem Verzeichnis noch in einem der Unterverzeichnisse eine Access-Datei befindet. Und genau dies wollen wir ja verhindern, um nur die notwendigsten Verzeichnisse und Dateien in der Tabelle zu speichern.<\/p>\n Zur Veranschaulichung liefert Bild 3 einige Verzeichnisse und Dateien. Die Beschriftungen rechts neben den Elementen enthalten die Werte für das Primärschlüsselfeld DateiVerzeichnisID <\/b>(in der Abbildung id<\/b>) und für das Fremdschlüsselfeld VerzeichnisID <\/b>(in der Abbildung fid<\/b>).<\/p>\n Bild 3: Indizierung der Verzeichnisse und Dateien<\/span><\/b><\/p>\n Das Speichern des ersten Elements c:\\ <\/b>ist kein Problem – dieses soll auf jeden Fall gespeichert werden. Es erhält als Primärschlüsselwert etwa den Wert 1<\/b>. Das Fremdschlüsselfeld bleibt leer, weil es ja keine übergeordneten Verzeichnisse gibt.<\/p>\n Das Unterverzeichnis Verzeichnis 1 <\/b>würde mit dem Primärschlüsselwert 2 <\/b>gespeichert. Das Feld VerzeichnisID <\/b>erhält den Primärschlüsselwert des übergeordneten Verzeichnisses, also 1<\/b>. Das Unterverzeichnis Verzeichnis 1-1 <\/b>erhält den Primärschlüsselwert 3 <\/b>und wird über den Wert 2 <\/b>für das Feld VerzeichnisID <\/b>dem Verzeichnis mit dem Primärschlüsselwert 2 <\/b>untergeordnet.<\/p>\n Nun folgt die erste Datei, die nach dem gängigen Schema den Wert 4 <\/b>im Feld DateiVerzeichnisID <\/b>und den Wert 3 <\/b>im Fremdschlüsselfeld VerzeichnisID <\/b>erhält.<\/p>\n Wenn alle Verzeichnisse am Ende mindestens eine Datenbankdatei im letzten Verzeichnis enthielten, könnte man die Dateien auf diese Weise anlegen und durchlaufen. Es müssen jeweils die übergeordneten Verzeichnisse zuerst angelegt werden, damit den darunter befindlichen Elementen die Primärschlüsselwerte als Fremdschlüsselwert zugeordnet werden können.<\/p>\n Nun gibt es aber Verzeichnisse wie Verzeichnis1-2<\/b>, das leer ist oder nur Dateien enthält, die nicht in die Tabelle aufgenommen werden sollen. Wir würden es mit den Werten 5 <\/b>im Feld DateiVerzeichnisID <\/b>und 2 <\/b>im Feld VerzeichnisID <\/b>speichern. Erst danach würden wir die in diesem Verzeichnis enthaltenen Elemente durchlaufen und schließlich feststellen, dass dort keine Datenbankdatei zu finden ist.<\/p>\n In diesem Fall gibt es kein weiteres untergeordnetes Verzeichnis, sodass die Untersuchung schnell abgeschlossen ist. Was aber nun mit dem Datensatz für das Verzeichnis mit dem Namen Verzeichnis 1-2<\/b> Der Datensatz kann wieder gelöscht werden, da er ja nicht mehr benötigt wird. Dummerweise gibt es gelegentlich sehr tiefe Verzeichnisstrukturen, in denen sich keine Datenbankdateien finden lassen. Dort würde man erst einige Datensätze für die Verzeichnisstruktur anlegen und müsste diese anschließend wieder löschen.<\/p>\n Dies ist der Grund, warum wir keinen Autowert als Primärschlüsselwert verwenden: Damit die Datensätze für Verzeichnisse ohne untergeordnete Datenbanken gar nicht erst angelegt werden, soll die entsprechende Funktion sich erst rekursiv bis zum Ende der Verzeichnisstruktur bewegen und prüfen, ob dort Datenbankdateien vorliegen. Ist dies der Fall, legt die Funktion zunächst das Element für die Datenbankdatei an und dann die darüber liegenden Verzeichnisse. Sprich: Im Falle von Datei 1 <\/b>würde erst ein Datensatz für die Datei, dann jeweils einer für Verzeichnis 1-1 <\/b>und für Verzeichnis 1 <\/b>angelegt werden.<\/p>\n Dummerweise wissen wir beim Anlegen der untergeordneten Elemente noch nicht, welchen Primärschlüsselwert dessen Verzeichnis in der Tabelle aufweist. Wir müssen beim Navigieren in Richtung untergeordneter Verzeichnisse einen Primärschlüsselwert vorhalten und diesen dann von unten nach oben als Fremdschlüsselwert des jeweils untergeordneten Elements einfügen.<\/p>\n Wenn dabei wie im Fall von Verzeichnis 1-2 <\/b>zunächst ein Primärschlüsselwert wie etwa 5 <\/b>festgelegt wird, sich aber herausstellt, dass dieses Verzeichnis keine Access-Datenbanken enthält und somit nicht gespeichert werden soll, kann der Primärschlüsselwert 5 <\/b>für das nachfolgend untersuchte Verzeichnis reserviert werden.<\/p>\n Rekursive Einlesefunktion<\/b><\/p>\n Wie lässt sich dies per VBA umsetzen Ganz einfach – mit einer rekursiv definierten Funktion. Diese besteht im vorliegenden Fall aus einer initialisierenden Funktion, die einen oder mehrere Datensätze für das angegebene Root-Verzeichnis schreibt und dann die eigentliche rekursive Funktion aufruft.<\/p>\n Schauen wir uns zunächst die Parameter der Startprozedur DateienEinlesen <\/b>an (s. Listing 1<\/a><\/span>):<\/p>\n Listing 1: Prozedur zum Initiieren des rekursiven Dateieinlese-Vorgangs<\/p>\n Die Prozedur deklariert zunächst ein Objekt auf Basis von Scripting.FileSystemObject<\/b>. Dieses liefert die Methoden und Eigenschaften, um auf das Dateisystem zuzugreifen. Außerdem benötigen wir eine Database<\/b>-Variable, um per Execute<\/b>-Methode SQL-Aktionsabfragen ausführen zu können.<\/p>\n Die Prozedur prüft zunächst, ob der Parameter strPfad <\/b>übergeben wurde und ersetzt diesen gegebenenfalls durch das Verzeichnis c:\\<\/b>. Der folgende Aufruf der GetFolder<\/b>-Funktion des FileSystemObjects <\/b>entledigt den Inhalt von strPfad <\/b>eventuell anhängender Backslash-Zeichen, aus c:\\Daten\\ <\/b>wird also c:\\Daten<\/b>.<\/p>\n Die folgende Anweisung kopiert den kompletten Inhalt der Tabelle tblDateienVerzeichnisse <\/b>in eine neue Tabelle, die den gleichen Namen erhält, jedoch um Datum und Uhrzeit ergänzt. Dieses Feature war während der Entwicklung hilfreich, um umfangreiche erfolgreiche Einlesevorgänge zu sichern, bevor der Code weiter verfeinert wurde.<\/p>\n Danach leert die Tabelle tblDateienVerzeichnisse<\/b>, da diese ja nun neu gefüllt werden soll. Ist das in strPfad <\/b>angegebene Verzeichnis vorhanden, beginnt die eigentliche Bearbeitung.<\/p>\n Wenn der Benutzer einen Pfad angibt, der aus mehr als nur dem Laufwerksbuchstaben besteht, soll die Prozedur nämlich für jedes enthaltene Verzeichnis gleich einen Eintrag zur Tabelle tblDateienVerzeichnisse <\/b>hinzufügen – und zwar verschachtelt. Dazu überträgt die Prozedur zunächst mit der Split<\/b>-Funktion alle Verzeichnisse des Pfades in ein Array namens strVerzeichnisse()<\/b>.<\/p>\n Die folgende For…Next<\/b>-Schleife durchläuft dazu alle Elemente dieses Arrays und legt jeweils einen neuen Eintrag in der Tabelle tblDateienVerzeichnisse <\/b>an. Dabei gibt es wiederum zwei Möglichkeiten: Hat die Laufvariable i <\/b>den Wert 0<\/b>, wird das erste Element mit einer SQL-Anweisung wie folgt in die Tabelle tblDateienVerzeichnisse <\/b>eingetragen:<\/p>\n Das heißt, dass das Feld VerzeichnisID <\/b>zum Eintragen der Referenz auf das übergeordnete Verzeichnis leer bleibt. Für die übrigen Einträge gibt die Prozedur jeweils das übergeordnete Verzeichnis als weiteren Parameter der INSERT INTO<\/b>-Anweisung an:<\/p>\n In diesem Fall referenziert das hier angelegte zweite Element mit dem Primärschlüsselwert 2 <\/b>das erste Element mit dem Primärschlüsselwert 1 <\/b>über das Feld VerzeichnisID <\/b>mit dem Wert 1<\/b>. Wenn Sie mit dem Parameter strPfad<\/b> also beispielsweise den Pfad c:\\Daten\\Fachartikel\\AccessImUnternehmen\\2013\\03\\<\/b> übergeben, sieht der Inhalt der Tabelle tblDateienVerzeichnisse <\/b>nach dem Durchlaufen der For…Next<\/b>-Schleife wie in Bild 4 aus. <\/p>\n Bild 4: Datensätze für den als Parameter übergebenen Pfad<\/span><\/b><\/p>\n Damit ist der erste Teil erledigt – alle Verzeichnisse des übergebenen Pfades wurden in der Tabelle angelegt. <\/p>\n Nun geht es mit der eigentlichen rekursiven Funktion weiter, die alle unterhalb dieses Pfades befindlichen Verzeichnisse und Dateien untersucht. Vorher stellt die Prozedur jedoch noch die wie folgt global deklarierte Variable lngAktuellID<\/b> auf den Wert der Laufvariablen i <\/b>ein:<\/p>\n lngAktuellID <\/b>speichert den jeweils zu verwendenden Primärschlüsselwert beim Anlegen eines neuen Datensatzes.<\/p>\n Rekursive Funktion<\/b><\/p>\n Die rekursiv definierte Funktion DateienEinlesenRek <\/b>erwartet die folgenden Parameter:<\/p>\n Die Funktion DateienEinlesenRek <\/b>stellt zunächst die als Parameter übergebene Variable lngAnzahl <\/b>auf den Wert 0 <\/b>ein (s. Listing 2<\/a><\/span>). Diese Variable soll, sofern das aktuelle Verzeichnis Datenbankdateien enthält, entsprechend angepasst werden. Außerdem werden noch die in den unterhalb des aktuellen Verzeichnisses befindlichen Datenbankdateien hinzugezählt.<\/p>\n Listing 2: Rekursiver Teil der Routinen zum Einlesen der Verzeichnisstruktur und der enthaltenen Dateien<\/p>\n <\/p>\n Dann prüft sie, ob der Benutzer überhaupt einen Wert für den Parameter intTiefeMax <\/b>angegeben hat und somit eine maximal zu durchsuchende Verzeichnistiefe. Falls ja, vergleicht sie diesen Wert mit der in intTiefe <\/b>gespeicherten aktuellen Verzeichnistiefe.<\/p>\n Sollte die maximale Tiefe erreicht worden sein, bricht die Funktion sich selbst ab. Danach untersucht die Funktion zunächst alle Dateien des aktuellen Verzeichnisses, und zwar in einer For Each<\/b>-Schleife über alle Objekte der Files<\/b>-Auflistung des mit objVerzeichnis <\/b>referenzierten aktuellen Verzeichnisses.<\/p>\n Die folgende Select Case<\/b>-Bedingung prüft den Wert der mit der Funktion GetExtensionName <\/b>ermittelten Dateiendung. Hat diese den Wert mdb<\/b>, accdb<\/b>, mda<\/b>, accda<\/b>, mde <\/b>oder accde<\/b>, handelt es sich um eine Datenbankdatei.<\/p>\n Sie können an dieser Stelle weitere Dateiendungen hinzufügen oder diese komplett ändern, um beispielsweise alle Word-Dokumente eines Verzeichnisses zu ermitteln. Wurde eine der angegebenen Dateiendungen gefunden, erhöht die Funktion den Wert von lngAnzahl <\/b>um eins. Dann trägt sie die gefundene Datenbankdatei in die Tabelle tblDateienVerzeichnisse <\/b>ein, und zwar beispielsweise mit folgender SQL-Anweisung:<\/p>\n Danach erhöht die Funktion den Wert von lngAktuellID <\/b>um eins. Diese Variable hat eine wichtige Aufgabe: Sie liefert den Wert für den jeweils neu anzulegenden Datensatz in der Tabelle tblDateienVerzeichnisse <\/b>– sowohl beim Anlegen von Dateien als auch bei Verzeichnissen. Weiter oben haben wir ja bereits darauf hingewiesen, dass die Tabelle tblDateienVerzeichnisse <\/b>keinen Autowert für das Primärschlüsselfeld verwendet, daher muss dieser Wert von der Funktion DateienEinlesenRek <\/b>gepflegt werden.<\/p>\n Um lngAktuellID <\/b>nicht immer als Parameter von Aufruf zu Aufruf weiterreichen zu müssen, haben wir diese Variable extern als modulweit gültige Variable deklariert. Sie läuft also quasi neben den Funktionsaufrufen her und wird darin jeweils erhöht, um immer einen eindeutigen Primärschlüsselwert bereitzustellen.<\/p>\n Wenn die Funktion in diesem Durchlauf mindestens eine Datenbankdatei gefunden hat, stellt sie den Wert des Rückgabewertes DateienEinlesenRek <\/b>auf True <\/b>ein. Dieser Wert bleibt auch erhalten, bis alle Dateien und Unterverzeichnisse des aktuellen Verzeichnisses durchlaufen wurden, und wird höchstens mehrfalls auf True <\/b>eingestellt.<\/p>\n Nachdem alle eventuell vorhandenen Dateien durchlaufen und auf Datenbankdatei-Endungen geprüft wurden, durchläuft die Funktion die enthaltenen Unterverzeichnisse – ebenfalls in einer For Each<\/b>-Schleife. Zuvor stellt die Prozedur noch eine Variable namens bolVaterverzeichnisSpeichern <\/b>auf False <\/b>ein – dazu später mehr.<\/p>\n Für jedes gefundene Verzeichnis speichert die Funktion zunächst den aktuellen Wert von lngAktuellID<\/b>, unserer Primärschlüsselwert-Quelle, in der Variablen lngDateiVerzeichnisID <\/b>und erhöht lngAktuellID <\/b>wiederum um eins.<\/p>\n Bevor das aktuell durchlaufene Verzeichnis gespeichert wird, ruft sich die Funktion zunächst erneut selbst auf, um die in diesem Verzeichnis enthaltenen Unterverzeichnisse zu untersuchen. Warum das Nun: Wenn Sie das Verzeichnis vorher schon speichern, ohne dass dieses eine Datenbankdatei enthält und ohne die Unterverzeichnisse zu durchsuchen, kann es sein, dass dieses Verzeichnis später wieder gelöscht werden muss. In unserer Variante des Speicherns der Verzeichnisstruktur durchlaufen wir zunächst alle Unterverzeichnisebenen und speichern Verzeichnisse erst, wenn mindestens eine Datenbankdatei in einem der Unterverzeichnisse enthalten ist.<\/p>\n Das ist ja der Trick: Die Lösung soll nur solche Verzeichnisse liefern, die auch Datenbankdateien enthalten. Alles andere würde nur die Übersicht verschlechtern.<\/p>\n Zurück zur Funktion: Diese ruft sich wie erwähnt erneut selbst auf, und zwar so lange, bis keine weiteren Unterverzeichnisse mehr gefunden werden oder bis die maximal zu durchsuchende Verzeichnistiefe erreicht ist. Wenn die Funktion irgendwann während dieses Vorgangs eine Datenbankdatei gefunden hat, liefert sie als Funktionswert den Wert True <\/b>zurück – dies geschieht ja bereits weiter oben beim Durchlaufen der im aktuellen Verzeichnis enthaltenen Dateien.<\/p>\n Aber nicht nur das: Beim Aufruf der Funktion DateienEinlesenRek <\/b>liefert der Rückgabeparameter lngAnzahlRek <\/b>den in diesem Aufruf ermittelten Wert der Variablen lngAnzahl<\/b>, also die Anzahl der im Verzeichnis gefundenen Datenbankdateien. Dieser durch die Funktion gefüllte Wert wird zum aktuellen Wert der Variablen lngAnzahl <\/b>hinzuaddiert. Auf diese Weise wird die Anzahl der Datenbankdateien von den untersten Verzeichnisebenen nach oben hin aufkumuliert, sodass für jedes Verzeichnis die insgesamt in allen Unterverzeichnissen enthaltene Anzahl Datenbankdateien gespeichert werden kann.<\/p>\n Eine weitere Variable namens bolVaterverzeichnisSpeichern <\/b>legt fest, ob das übergeordnete Verzeichnis entweder wegen einer in diesem Verzeichnis liegenden Datenbankdatei oder wegen einer in den darunter liegenden Verzeichnissen enthaltenen Datenbankdatei gespeichert werden soll. bolVaterverzeichnisSpeichern <\/b>wird beim ersten Auftauchen eines Verzeichnisses mit Datenbankdatei auf True <\/b>eingestellt und Ebene für Ebene in der Hierarchie der Funktionsaufrufe nach oben durchgereicht.<\/p>\n Hat bolDiesesVerzeichnisSpeichern <\/b>den Wert True<\/b>, legt die Prozedur in der Tabelle tblDateienVerzeichnisse <\/b>einen Datensatz für das aktuelle Verzeichnis an.<\/p>\n Das bedeutet, dass bei Durchlaufen eines Pfades wie c:\\Verzeichnis1\\Verzeichnis2\\Verzeichnis3 <\/b>und dem Auffinden einer Datenbankdatei in Verzeichnis 3 die rekursive Funktion zunächst in das Verzeichnis c:\\Verzeichnis1\\Verzeichnis2\\Verzeichnis3 <\/b>abtaucht und dieses speichert und erst dann c:\\Verzeichnis1\\Verzeichnis2 <\/b>und c:\\Verzeichnis1<\/b>.<\/p>\n Schließlich gibt die Prozedur als Funktionswert den Wert True <\/b>zurück, wenn in diesem oder einen weiteren rekursiven Aufruf mindestens eine Datenbankdatei gefunden werden konnte.<\/p>\n Nach dem Aufruf und dem Abarbeiten der rekursiven Funktion ist die Tabelle tblDateienVerzeichnisse <\/b>mit den gewünschten Daten gefüllt und kann für die Anzeige im TreeView-Steuerelement weiterverwendet werden.<\/p>\n Formular erstellen<\/b><\/p>\n Nach den etwas umfangreicheren Vorbereitungen erstellen wir nun das Formular zur Anzeige und Auswahl von Datenbankdateien. Das Formular soll frmDateienVerzeichnisse <\/b>heißen. Im Kopf des Formulars legen wir ein Textfeld namens txtStartverzeichnis <\/b>zur Eingabe\/Auswahl des Startverzeichnisses beim Einlesen der Verzeichnisse an. Rechts daneben platzieren wir eine Schaltfläche, die einen Verzeichnisauswahl-Dialog einblendet und die getroffene Auswahl in das Textfeld txtStartverzeichnis <\/b>überträgt.<\/p>\n Diese Schaltfläche verwendet die folgende Prozedur, um eine im Modul mdlTools<\/b> befindliche Funktion zum Ermitteln eines Verzeichnisses aufzurufen:<\/p>\n Darunter platzieren wir zwei Schaltflächen namens cmdEinlesen <\/b>und cmdBaumFuellen<\/b>. Die Schaltfläche cmdEinlesen <\/b>startet die Prozedur DateienEinlesen <\/b>mit dem im Textfeld angegebenen Verzeichnis:<\/p>\n Die Schaltfläche cmdBaumFuellen <\/b>ruft die noch zu erstellende Prozedur BaumFuellen <\/b>auf:<\/p>\n Da das Formular nicht an eine Datenherkunft gebunden ist, können Sie Eigenschaften wie Navigationsschaltflächen<\/b>, Datensatzmarkierer <\/b>und Bildlaufleisten <\/b>auf Nein <\/b>einstellen.<\/p>\n Dateien im TreeView-Steuerelement<\/b><\/p>\n Nun soll das TreeView-Steuerelement mit den Daten der Tabelle tblDateienVerzeichnisse <\/b>gefüllt werden. Das TreeView-Steuerelement soll ein paar aussagekräftige Icons anzeigen, es soll sich merken, welche Einträge beim vorherigen Bearbeiten ein- und welche ausgeklappt waren, und es soll folgende Kontextmenüeinträge für die Datenbankeinträge bereitstellen (s. Bild 6):<\/p>\n Bild 5: Diese Abfrage liefert das Root-Element für das TreeView-Steuerelement<\/span><\/b><\/p>\n Bild 6: Kontextmenü eines Datenbankeintrags<\/span><\/b><\/p>\n Außerdem soll das Textfeld txtDatei <\/b>im unteren Bereich nach einem Klick auf einen der TreeView-Einträge mit dem Namen der jeweiligen Datenbankdatei gefüllt werden.<\/p>\n Klickt der Benutzer auf ein Verzeichnis, soll das Textfeld geleert werden.<\/p>\n Dies sind bereits einige Anforderungen an ein TreeView-Steuerelement. Grund genug, den TreeViewHandler, den wir zuletzt im Beitrag TreeView-Konfigurator erweitert <\/b>(www.access-im-unternehmen.de\/771<\/b>) vorgestellt haben, einzusetzen.<\/p>\n Mit diesem lässt sich das TreeView leicht konfigurieren und füllen. Außerdem bringt der TreeViewHandler einige Funktionen wie das Speichern der Expanded<\/b>-Eigenschaft mit, die Sie sonst selbst programmieren müssten.<\/p>\n TreeViewHandler konfigurieren<\/b><\/p>\n Alle für den TreeViewHandler benötigten Komponenten sind bereits in der Beispieldatenbank AlleDatenbankenEinlesen.mdb <\/b>enthalten. Um das Steuerelement zu konfigurieren, öffnen Sie das Formular frmTreeViewConf <\/b>der Beispieldatenbank.<\/p>\n Die erste Ebene soll allein den Root-Eintrag der Tabelle tblDateienVerzeichnisse <\/b>anzeigen, also denjenigen, dessen Feld VerzeichnisID <\/b>den Wert Null <\/b>enthält. Speziell für diesen Zweck haben wir eine Abfrage namens qryDateienVerzeichnisseRoot<\/b> angelegt (s. Bild 5), das nur den besagten Root-Eintrag liefert.<\/p>\n Im TreeView-Konfigurator legen Sie nun einen neuen Eintrag an und stellen die Eigenschaften wie in Bild 7 ein:<\/p>\n Bild 7: Eigenschaften für das Root-Element im TreeView-Konfigurator<\/span><\/b><\/p>\n Zur Eigenschaft Icon <\/b>ist anzumerken, dass wir die verwendeten Bilddateien zunächst mit dem Tool aus dem Artikel Bilder per Add-In in OLE-Feld speichern <\/b>(www.access-im-unternehmen.de\/890<\/b>) in der Tabelle tblImages <\/b>gespeichert haben. Der TreeView-Konfigurator verwendet eine solche Tabelle, um die Bilddateien für die TreeView- und Kontextmenü-Icons zu beziehen.<\/p>\n Wir wollen diesen einen Eintrag zunächst im TreeView-Steuerelement erscheinen lassen. Dazu fügen Sie dem Formular frmDateienVerzeichnisse <\/b>ein ImageList<\/b>-Steuerelement namens ctlImageList <\/b>und ein TreeView<\/b>-Steuerelement namens ctlTreeView <\/b>hinzu.<\/p>\n Dazu legen Sie zunächst eine Objektvariable für die TreeViewHandler-Klasse im Kopf des Klassenmoduls Form_frmDateienVerzeichnisse <\/b>an:<\/p>\n Fügen Sie dann eine Ereignisprozedur hinzu, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird. Diese enthält aktuell nur eine einzige Anweisung:<\/p>\n Die hier aufgerufene Prozedur BaumFuellen <\/b>sieht wie folgt aus:<\/p>\n Die Prozedur instanziert ein neues Objekt auf Basis der Klasse clsTreeViewHandler <\/b>und stellt dessen Eigenschaften ein. Unter anderem weist sie ihr zunächst Objektverweise auf das zu verwendende ImageList<\/b>– und das TreeView<\/b>-Steuerelement zu.<\/p>\n Dann stellt sie mit der InitTreeView<\/b>-Methode die ID der zu verwendenden TreeView<\/b>-Konfiguration aus dem Formular frmTreeViewConf <\/b>ein – in diesem Fall lautet diese 7 <\/b>(sieht frmTreeViewConf<\/b>, oben links unter Aktuelle ID<\/b>).<\/p>\n Danach legt die Prozedur einige optische Eigenschaften fest und füllt das TreeView<\/b>-Steuerelement schließlich mit der FillTree<\/b>-Methode. Im ersten Versuch sieht dies wie in Bild 8 aus.<\/p>\n Bild 8: Das TreeView-Steuerelement zeigt zunächst nur das Root-Element an.<\/span><\/b><\/p>\n Weitere Verzeichnisse anzeigen<\/p>\n Nun folgt ein weiterer Eintrag im TreeView-Konfigurator, der für die erste Ebene unter dem Root-Element verantwortlich ist.<\/p>\n Auch für diesen legen wir wieder eine spezielle Datenherkunft an – sie sieht wie in Bild 9 aus und heißt qryVerzeichnisseBaum<\/b>. Das zweite Feld dieser Abfrage mit dem Namen DateiVerzeichnis <\/b>enthält den folgenden Ausdruck:<\/p>\n Bild 9: Datenherkunft für die zweite und die folgenden Ebenen im TreeView-Steuerelement<\/span><\/b><\/p>\n Dieser ergänzt den Verzeichnisnamen gegebenenfalls um die in Klammern eingefasste Anzahl der in diesem Verzeichnis enthaltenen Datenbankdateien.<\/p>\n Für das Feld IstVerzeichnis <\/b>haben wir als Kriterium Wahr <\/b>eingestellt und für das Fremdschlüsselfeld VerzeichnisID <\/b>das Kriterium Ist Nicht Null<\/b>. Auf diese Weise werden nur Verzeichnisse erfasst, und nur solche, die Unterverzeichnis eines anderen Verzeichnisses sind.<\/p>\n Im TreeView-Konfigurator stellen Sie die folgenden Eigenschaften für den neuen Eintrag für diese Ebene ein:<\/p>\n Die übrigen Eigenschaften entsprechen denen des übergeordneten Elements.<\/p>\n Durch diesen Eintrag werden in der zweiten Ebene des TreeViews alle Einträge der Abfrage qryVerzeichnisseBaum <\/b>eingefügt, deren Fremdschlüsselfeld VerzeichnisID <\/b>dem Primärschlüsselfeld des Elements der ersten Ebene entspricht.<\/p>\n Weitere Verzeichnisebenen<\/b><\/p>\n Nun wollen wir nicht jede Ebene einzeln anlegen (das wäre auch kompliziert, da wir nicht wissen, wie viele Ebenen es gibt).<\/p>\n Aber wir wissen ja, dass die Tabelle tblDateienVerzeichnisse <\/b>mit sich selbst verknüpfte Elemente enthält.<\/p>\n Und da der TreeView-Konfigurator auch reflexive Daten unterstützt, legen wir dort als weitere Ebene eine solche an. Die Eigenschaften sehen so aus:<\/p>\n Die Elemente für diesen Eintrag referenzieren also Elemente der gleichen Tabelle, deren Primärschlüsselfeld den Wert des Fremdschlüsselfelds des aktuellen Datensatzes aufweist. Auf diese Weise werden die folgenden Verzeichnisebenen rekursiv angelegt. Das Zwischenergebnis sieht wie in Bild 10 aus.<\/p>\n Bild 11: Datenherkunft für die Datei-Ebene im TreeView-Steuerelement<\/span><\/b><\/p>\n Dateien im TreeView<\/b><\/p>\n Nun fehlen nur noch die Dateien der jeweiligen Verzeichnisse. Dazu legen Sie eine vierte und letzte Ebene im TreeView-Konfigurator an. Auch diese basiert wieder auf einer eigens zu diesem Zweck erzeugten Abfrage. Sie heißt qryDateienBaum<\/b> und sieht wie in Bild 11 aus. Die Besonderheit dieser Abfrage liegt darin, dass sie ausschließlich solche Datensätze liefert, deren Feld IstVerzeichnis <\/b>den Wert Falsch <\/b>enthält.<\/p>\n Bild 10: Rekursiv angelegte Verzeichnisstruktur<\/span><\/b><\/p>\n Die Eigenschaften für den entsprechenden Eintrag im TreeView-Konfigurator lauten wie folgt:<\/p>\n Beim nächsten Anzeigen des Formulars frmDateienVerzeichnisse <\/b>erscheinen nun auch die Einträge für die Datenbankdateien im TreeView-Steuerelement.<\/p>\n Kontextmenüeinträge<\/b><\/p>\n Für die im TreeView angezeigten Dateien fehlen noch die Kontextmenü-Einträge. Diese fügen Sie ebenfalls über den TreeView-Konfigurator hinzu. Dazu tragen Sie im unteren Bereich einfach die Bezeichnungen ein und geben die Bilddateien an (s. Bild 12).<\/p>\n Bild 12: Konfiguration für die Dateieinträge samt Kontextmenü-Einträgen<\/span><\/b><\/p>\n Außerdem können Sie unter ContextmenuParameter <\/b>noch einen Parameter eintragen, der beim Anklicken eines der Kontextmenü-Einträge an die dadurch ausgelöste Ereignisprozedur weitergeleitet wird. Die Einträge sehen wie folgt aus:<\/p>\n Nun fehlen nur noch ein paar Ereignisprozeduren.<\/p>\n Ereignisprozeduren des TreeView-Steuerelements<\/b><\/p>\n Schauen wir uns zunächst die Prozedur an, die durch das Betätigen der Kontextmenü-Einträge ausgelöst wird. Diese fügen Sie dem Klassenmodul Form_frmDateienVerzeichnisse <\/b>über die Kombinationsfelder oben im Code-Fenster hinzu (links objTreeViewHandler <\/b>auswählen, rechts ShortcutMenuClick<\/b>).<\/p>\n Die nun erscheinende Prozedur ergänzen Sie wie in Listing 3<\/a><\/span>. Die Prozedur ermittelt zunächst per DLookup<\/b>-Funktion den Pfad der Datei, die der Benutzer mit der rechten Maustaste angeklickt hat.<\/p>\n Listing 3: Ereignisprozedur, die durch das Anklicken eines Kontextmenü-Eintrags ausgelöst wird<\/p>\n Sie erhält außerdem über den Parameter strParameter <\/b>den für ContextMenuParameter <\/b>festgelegten Ausdruck, also entweder Delete<\/b>, OpenDatabase <\/b>oder ShowFolder<\/b>. In Abhängigkeit davon führt die Prozedur einen der drei Zweige der Select Case<\/b>-Bedingung aus.<\/p>\n Der erste löscht die aktuelle Datenbankdatei nach vorheriger Rückfrage, der zweite öffnet den Windows Explorer und navigiert dort gleich zum Verzeichnis, in dem sich die Datenbank befindet, und der dritte öffnet die Datenbank mit Access.<\/p>\n Bei Klick Dateipfad anzeigen<\/b><\/p>\n Eine weitere Ereignisprozedur wird durch einen Mausklick auf einen beliebigen Eintrag im TreeView-Steuerelement ausgelöst. Die Prozedur heißt objTreeViewHandler_NodeClick <\/b>und liefert beispielsweise den Primärschlüsselwert des angeklickten Elements.<\/p>\n Damit ermittelt die Ereignisprozedur den passenden Dateinamen aus der Tabelle tblDateienVerzeichnisse <\/b>und zeigt diesen im Textfeld txtDatei <\/b>an, den wir noch unterhalb des TreeView-Steuerelements einfügen (s. Listing 4<\/a><\/span>).<\/p>\n Listing 4: Ereignisprozedur, die durch das Anklicken eines Datei-Eintrags ausgelöst wird<\/p>\n Rückgabe des gewählten Verzeichnisnamens<\/b><\/p>\n Der Sinn des Formulars besteht unter anderem darin, zu bestimmten Gelegenheiten zu erscheinen, die Auswahl einer Datenbankdatei zu erlauben und diese dann weiterzuverarbeiten. Dies gelingt mit ein paar Erweiterungen der aktuellen Version.<\/p>\n Die Funktion aus Listing 5<\/a><\/span> öffnet das Formular als modalen Dialog und wartet, bis dieses wieder geschlossen wird. Da Sie einem geschlossenen Formular keine gewählten Werte mehr entlocken können, wird es nicht direkt geschlossen, sondern unsichtbar gemacht – so läuft der aufrufende Code weiter und kann direkt auf die Steuerelemente des Formulars zugreifen.<\/p>\n Listing 5: Aufruf des Formulars mit Rückgabe der gewählten Datenbankdatei<\/p>\n Im Formular realisieren wir das Verstecken des Formulars durch eine OK<\/b>-Schaltfläche mit folgender Ereignisprozedur:<\/p>\n Nach dem Schließen liest die Funktion DatenbankErmitteln <\/b>den Inhalt des Textfeldes txtDatei <\/b>aus und schließt das Formular dann endgültig.<\/p>\n Damit das Formular direkt das gewünschte Startverzeichnis anzeigt, erlaubt die Funktion DatenbankErmitteln <\/b>die Angabe einer entsprechenden Zeichenkette. Diese leitet die Funktion per OpenArgs<\/b>-Parameter an das zu öffnende Formular weiter.<\/p>\n Beim Öffnen des Formulars wertet die erweiterte Fassung der Form_Load<\/b>-Prozedur das Öffnungsargument aus und schreibt es in die Variable strAktuellesVerzeichnis<\/b>.<\/p>\n Nun ist es so, dass es nicht gerade trivial ist, genau das gewünschte Element im TreeView-Steuerelement aufzuklappen.<\/p>\n Deshalb benötigen wir dazu eine eigene Prozedur namens ZielverzeichnisAusklappen<\/b>. Diese erwartet das gewünschte Verzeichnis sowie eine weitere Variable, welche den Wert der Eigenschaft Key <\/b>des resultierenden Elements zurückliefert. Dieses verarbeitet die Prozedur weiter, indem sie genau dieses Element mit der ClickNode<\/b>-Methode des TreeViewHandler<\/b>-Objekts markiert:<\/p>\n Die Prozedur ZielverzeichnisAusklappen <\/b>wirkt sich nicht direkt auf die Anzeige der Elemente im TreeView-Steuerelement aus.<\/p>\n Daher ist vor dem Markieren des Zielelements noch die Anzeige mit der Prozedur BaumFuellen <\/b>zu aktualisieren.<\/p>\n Direktes Anzeigen eines Verzeichnisses beim Öffnen<\/b><\/p>\n Das Arbeitstier beim Ausklappen eines gewünschten Zielverzeichnisses ist die Prozedur ZielverzeichnisAusklappen <\/b>mit ihrer rekursiven Ergänzung ElementMarkierenRek<\/b> (s. Listing 6<\/a><\/span>). Die erstgenannte Prozedur erwartet die genannten Parameter und ermittelt zunächst einen Eintrag aus der Tabelle tblDateienVerzeichnisse<\/b>, dessen Pfad dem mit strVerzeichnis <\/b>übergebenen nahekommt. Mit dessen Primärschlüsselwert ermittelt die Prozedur dann den übergeordneten Eintrag. Ist dieser vorhanden, ruft die Prozedur die rekursive Funktion ElementMarkierenRek <\/b>auf.<\/p>\n Listing 6: Prozedur, die alle Elemente bis zum angegebenen Verzeichnis ausklappt<\/p>\n Bevor wir diese ansehen, ein Ausblick auf das, was nun geschieht: Wir haben in der Tabelle tblDateienVerzeichnisse <\/b>den Datensatz ermittelt, der dem Pfad zu dem zu markierenden Element im TreeView entspricht. Nun wollen wir dafür sorgen, dass dieses angezeigt wird. Dazu müssen wir den Wert des Feldes Expanded <\/b>für diesen Datensatz und für alle Datensätze, die diesem direkt übergeordnet sind, auf den Wert True <\/b>einstellen. Wenn wir dann das TreeView-Steuerelement neu füllen, sollten alle Elemente bis zum Zielelement ausgeklappt sein und das Zielelement kann markiert werden.<\/p>\n Die Funktion ElementMarkierenRek<\/b><\/p>\n Zum Einstellen des Feldes Expanded <\/b>auf den Wert True <\/b>arbeiten wir uns Stück für Stück in der Hierarchie nach oben. Dazu benötigen wir eine rekursiv definierte Funktion, in diesem Fall ElementMarkierenRek<\/b> (s. Listing 7<\/a><\/span>). Diese erwartet als Parameter einen Verweis auf das aktuelle Database<\/b>-Objekt, die ID des zu untersuchenden Elements, eine Variable zum Übergeben der Verzeichnistiefe (ermittelt aus der Anzahl der Backslash-Zeichen des Verzeichnisses) und die Variable strKey<\/b>, welche die Key<\/b>-Eigenschaften der einzelnen Elemente bis zum Zielverzeichnis auflistet.<\/p>\n Listing 7: Rekursiver Teil der Funktion zum Ausklappen bis zu einem bestimmten Verzeichnis<\/p>\n Dazu müssen Sie wissen, dass der TreeView-Konfigurator den Wert der Eigenschaft Key <\/b>hierarchisch anlegt. Das bedeutet, dass das Root-Element v01 <\/b>heißt, das erste untergeordnete Element v01|vv1<\/b>, das nächste v01|vv1|vr1 <\/b>und so weiter. Wenn wir also am Ende das gewünschte Verzeichnis-Element markieren möchten, müssen wir die ![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2013_03\/DatenbankenAnzeigen-web-images\/pic001.png\")
<\/p>\n\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2013_03\/DatenbankenAnzeigen-web-images\/pic002.png\")
<\/p>\nPublic Sub DateienEinlesen(Optional strPfad As String, Optional intTiefeMax As Integer)\r\n Dim objFSO As Scripting.FileSystemObject\r\n Dim db As DAO.Database\r\n Dim strVerzeichnisse() As String\r\n Dim i As Long\r\n Set objFSO = New Scripting.FileSystemObject\r\n Set db = CurrentDb\r\n If Len(strPfad) = 0 Then\r\n strPfad = "c:\\"\r\n End If\r\n strPfad = objFSO.GetFolder(strPfad)\r\n If Right(strPfad, 1) = "\\" Then\r\n strPfad = Left(strPfad, Len(strPfad) - 1)\r\n End If\r\n db.Execute "SELECT * INTO tblDateienVerzeichnisse_" & Format(Now, "yyyymmdd_hhnnss") _\r\n & " FROM tblDateienVerzeichnisse", dbFailOnError\r\n db.Execute "DELETE FROM tblDateienVerzeichnisse", dbFailOnError\r\n If objFSO.FolderExists(strPfad) Then\r\n strVerzeichnisse = Split(strPfad, "\\")\r\n For i = LBound(strVerzeichnisse) To UBound(strVerzeichnisse)\r\n If i = 0 Then\r\n db.Execute "INSERT INTO tblDateienVerzeichnisse(DateiVerzeichnisID,\r\n DateiVerzeichnisName, IstVerzeichnis) VALUES(" & i + 1 & ", ''" _\r\n & strVerzeichnisse(i) & "'', -1)", dbFailOnError\r\n Else\r\n db.Execute "INSERT INTO tblDateienVerzeichnisse(DateiVerzeichnisID,\r\n DateiVerzeichnisName, IstVerzeichnis, VerzeichnisID) VALUES(" & i + 1 & ", ''" _\r\n & strVerzeichnisse(i) & "'', -1, " & i & ")", dbFailOnError\r\n End If\r\n Next i\r\n End If\r\n lngAktuellID = i + 1\r\n DateienEinlesenRek db, objFSO, objFSO.GetFolder(strPfad & "\\"), i, 0, intTiefeMax, 0\r\nEnd Sub<\/pre>\n\n
INSERT INTO tblDateienVerzeichnisse(DateiVerzeichnisID, DateiVerzeichnisName, IstVerzeichnis) VALUES(1, ''C:'', -1)<\/pre>\n
INSERT INTO tblDateienVerzeichnisse(DateiVerzeichnisID, DateiVerzeichnisName, IstVerzeichnis, VerzeichnisID) VALUES(2, ''Daten'', -1, 1)<\/pre>\n
![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2013_03\/DatenbankenAnzeigen-web-images\/pic004.png\")
<\/p>\nDim lngAktuellID As Long<\/pre>\n
\n
Public Function DateienEinlesenRek(db As DAO.Database, objFSO As Scripting.FileSystemObject, _\r\n objVerzeichnis As Scripting.Folder, lngVerzeichnisID As Long, intTiefe As Integer, _\r\n intTiefeMax As Integer, lngAnzahl As Long) As Boolean\r\n Dim objUnterverzeichnis As Scripting.Folder\r\n Dim objDatei As Scripting.File\r\n Dim lngDateiVerzeichnisID As Long\r\n Dim bolDiesesVerzeichnisSpeichern As Boolean\r\n Dim bolVaterverzeichnisSpeichern As Boolean\r\n Dim lngAnzahlRek As Long\r\n lngAnzahl = 0\r\n If (intTiefeMax > 0) And (intTiefe > intTiefeMax) Then\r\n Exit Function\r\n End If\r\n On Error Resume Next\r\n For Each objDatei In objVerzeichnis.Files\r\n Select Case objFSO.GetExtensionName(objDatei.Name)\r\n Case "mdb", "accdb", "mda", "accda", "mde", "accde"\r\n lngAnzahl = lngAnzahl + 1\r\n db.Execute "INSERT INTO tblDateienVerzeichnisse(DateiVerzeichnisID, " _\r\n & "DateiVerzeichnisName, IstVerzeichnis, VerzeichnisID, Pfad) VALUES(" _\r\n & lngAktuellID & ", ''" & objDatei.Name & "'', 0, " & lngVerzeichnisID & ", ''" _\r\n & objDatei.Path & "'')", dbFailOnError\r\n lngAktuellID = lngAktuellID + 1\r\n DateienEinlesenRek = True\r\n End Select\r\n Next objDatei\r\n bolVaterverzeichnisSpeichern = False\r\n For Each objUnterverzeichnis In objVerzeichnis.SubFolders\r\n lngDateiVerzeichnisID = lngAktuellID\r\n lngAktuellID = lngAktuellID + 1\r\n bolDiesesVerzeichnisSpeichern = DateienEinlesenRek(db, objFSO, objUnterverzeichnis, _\r\n lngDateiVerzeichnisID, intTiefe + 1, intTiefeMax, lngAnzahlRek)\r\n lngAnzahl = lngAnzahl + lngAnzahlRek\r\n bolVaterverzeichnisSpeichern = bolVaterverzeichnisSpeichern Or bolDiesesVerzeichnisSpeichern\r\n If bolDiesesVerzeichnisSpeichern = True Then\r\n db.Execute "INSERT INTO tblDateienVerzeichnisse(DateiVerzeichnisID, " _\r\n & "DateiVerzeichnisName, IstVerzeichnis, VerzeichnisID, EnthalteneDateien) VALUES(" _\r\n & lngDateiVerzeichnisID & ", ''" & objUnterverzeichnis.Name & "'', -1, " _\r\n & lngVerzeichnisID & ", " & lngAnzahlRek & ")", dbFailOnError\r\n End If\r\n Next objUnterverzeichnis\r\n DateienEinlesenRek = DateienEinlesenRek Or bolVaterverzeichnisSpeichern\r\nEnd Function<\/pre>\nINSERT INTO tblDateienVerzeichnisse(DateiVerzeichnisID, DateiVerzeichnisName, IstVerzeichnis, VerzeichnisID, Pfad)\r\nVALUES(12, ''ABCAnalyse.mdb'', 0, 11, ''C:\\Daten\\...\\ABCAnalyse.mdb'')<\/pre>\n
Private Sub cmdVerzeichnisWaehlen_Click()\r\n Me!txtStartverzeichnis = OpenPathName(CurrentProject.Path, "Startverzeichnis auswählen")\r\nEnd Sub<\/pre>\n
Private Sub cmdEinlesen_Click()\r\n DateienEinlesen Nz(Me!txtStartverzeichnis)\r\nEnd Sub<\/pre>\n
Private Sub cmdBaumFuellen_Click()\r\n BaumFuellen\r\nEnd Sub<\/pre>\n
![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2013_03\/DatenbankenAnzeigen-web-images\/pic006.png\")
<\/p>\n![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2013_03\/DatenbankenAnzeigen-web-images\/pic005.png\")
<\/p>\n\n
![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2013_03\/DatenbankenAnzeigen-web-images\/pic007.png\")
<\/p>\n\n
Dim WithEvents objTreeViewHandler As clsTreeViewHandler<\/pre>\n
Private Sub Form_Load()\r\n BaumFuellen\r\nEnd Sub<\/pre>\n
Private Sub BaumFuellen()\r\n Set objTreeViewHandler = New clsTreeViewHandler\r\n With objTreeViewHandler\r\n Set .TreeViewInst = Me!ctlTreeview.Object\r\n Set .ImageListInst = Me!ctlImageList.Object\r\n .InitTreeView (7)\r\n .Style = tvwTreelinesPlusMinusPictureText\r\n .LineStyle = tvwRootLines\r\n .Indentation = 5\r\n .FontName = "Calibri"\r\n .FontSize = 10\r\n .LabelEdit = tvwManual\r\n .FillTree\r\n End With\r\nEnd Sub<\/pre>\n
![\"pic008.png\"](\"..\/fileadmin\/_temp_\/2013_03\/DatenbankenAnzeigen-web-images\/pic008.png\")
<\/p>\n![\"pic009.png\"](\"..\/fileadmin\/_temp_\/2013_03\/DatenbankenAnzeigen-web-images\/pic009.png\")
<\/p>\nDateiVerzeichnis: [DateiVerzeichnisname] & Wenn([EnthalteneDateien];" (" & [EnthalteneDateien] & ")";"")<\/pre>\n\n
\n
![\"pic011.png\"](\"..\/fileadmin\/_temp_\/2013_03\/DatenbankenAnzeigen-web-images\/pic011.png\")
<\/p>\n![\"pic010.png\"](\"..\/fileadmin\/_temp_\/2013_03\/DatenbankenAnzeigen-web-images\/pic010.png\")
<\/p>\n\n
![\"pic012.png\"](\"..\/fileadmin\/_temp_\/2013_03\/DatenbankenAnzeigen-web-images\/pic012.png\")
<\/p>\n\n
Private Sub objTreeViewHandler_ShortcutMenuClick(objNode As MSComctlLib.Node, _\r\n strParameter As String, strThistable As String, strTableBase As String, strPKID As String, dblPKIDValue As Double)\r\n Dim strDateiname As String\r\n strDateiname = DLookup("Pfad", "tblDateienVerzeichnisse", "DateiVerzeichnisID = " & dblPKIDValue)\r\n Select Case strParameter\r\n Case "Delete"\r\n If MsgBox("Datei ''" & strDateiname & "'' löschen", vbYesNo + vbExclamation, "Datei löschen") = vbYes Then\r\n Kill strDateiname\r\n objTreeViewHandler.DeleteCurrentNode\r\n End If\r\n Case "OpenDatabase"\r\n Shell "Explorer.exe " & strDateiname, vbNormalFocus\r\n Case "ShowFolder"\r\n strDateiname = Left(strDateiname, InStrRev(strDateiname, "\\"))\r\n Shell "Explorer.exe " & strDateiname, vbNormalFocus\r\n End Select\r\nEnd Sub<\/pre>\nPrivate Sub objTreeViewHandler_NodeClick(objNode As MSComctlLib.Node, strTable As String, _\r\n strTableBase As String, strPKID As String, dblPKID As Double)\r\n Me!txtDatei = DLookup("Pfad", "tblDateienVerzeichnisse", "DateiVerzeichnisID = " & dblPKID)\r\nEnd Sub<\/pre>\nPublic Function DatenbankErmitteln(strPfad As String)\r\n DoCmd.OpenForm "frmDateienVerzeichnisse", WindowMode:=acDialog, OpenArgs:=strPfad\r\n If IstFormularGeoeffnet("frmDateienVerzeichnisse") Then\r\n DatenbankErmitteln = Forms!frmDateienVerzeichnisse!txtDatei\r\n DoCmd.Close acForm, "frmDateienVerzeichnisse"\r\n End If\r\nEnd Function<\/pre>\nPrivate Sub cmdOK_Click()\r\n Me.Visible = False\r\nEnd Sub<\/pre>\n
Private Sub Form_Load()\r\n Dim strKey As String\r\n Dim strAktuellesVerzeichnis As String\r\n strAktuellesVerzeichnis = Nz(Me.OpenArgs)\r\n If Len(strAktuellesVerzeichnis) > 0 Then\r\n ZielverzeichnisAusklappen strAktuellesVerzeichnis, strKey\r\n End If\r\n BaumFuellen\r\n If Len(strKey) > 0 Then\r\n objTreeViewHandler.ClickNode , , strKey\r\n End If\r\nEnd Sub<\/pre>\n
Private Sub ZielverzeichnisAusklappen(strVerzeichnis As String, strKey As String)\r\n Dim lngDateiVerzeichnisID As Long\r\n Dim lngVerzeichnisID As Long\r\n Dim db As DAO.Database\r\n Set db = CurrentDb\r\n lngDateiVerzeichnisID = Nz(DLookup("DateiVerzeichnisID", "tblDateienVerzeichnisse", _\r\n "Pfad LIKE ''" & strVerzeichnis & "*''"), 0)\r\n lngVerzeichnisID = Nz(DLookup("VerzeichnisID", "tblDateienVerzeichnisse", _\r\n "DateiVerzeichnisID = " & lngDateiVerzeichnisID), 0)\r\n If Not lngVerzeichnisID = 0 Then\r\n ElementMarkierenRek db, lngDateiVerzeichnisID, Len(strVerzeichnis) - _\r\n Len(Replace(strVerzeichnis, "\\", "")) + 1, strKey\r\n End If\r\nEnd Sub<\/pre>\nPrivate Sub ElementMarkierenRek(db As DAO.Database, lngVerzeichnisID As Long, intLevel As Integer, _\r\n Optional ByRef strKey As String)\r\n Dim lngDateiVerzeichnisID As Long\r\n lngDateiVerzeichnisID = lngVerzeichnisID\r\n lngVerzeichnisID = Nz(DLookup("VerzeichnisID", "tblDateienVerzeichnisse", "DateiVerzeichnisID = " & lngVerzeichnisID), 0)\r\n If Not lngVerzeichnisID = 0 Then\r\n lngDateiVerzeichnisID = lngVerzeichnisID\r\n db.Execute "UPDATE tblDateienVerzeichnisse SET Expanded = True WHERE DateiVerzeichnisID = " _\r\n & lngDateiVerzeichnisID, dbFailOnError\r\n Select Case intLevel\r\n Case 1\r\n strKey = "|v0" & lngDateiVerzeichnisID & strKey\r\n Case 2\r\n strKey = "|vv" & lngDateiVerzeichnisID & strKey\r\n Case Else\r\n strKey = "|vr" & lngDateiVerzeichnisID & strKey\r\n End Select\r\n ElementMarkierenRek db, lngVerzeichnisID, intLevel - 1, strKey\r\n If Left(strKey, 1) = "|" Then\r\n strKey = Mid(strKey, 2)\r\n End If\r\n End If\r\nEnd Sub<\/pre>\n