In Access-Anwendungen kann es interessant sein, Ordner und Dateien zu einem Datensatz verfügbar zu machen. Das bietet sich an, wann immer Dateien im Kontext eines Datensatzes in einem bestimmten Bereich im Dateisystem gespeichert sind – etwa zu Kunden, Projekten, Produkten und anderen Tabellen. In diesem Artikel zeigen wir, wie man die Verzeichnisse und Dateien eines Verzeichnisses über ein ListView-Steuerelement einfach in einem Formular anzeigen kann. Die Standardfunktionen zu diesen Elementen sollen direkt über die Einträge dieses ListView-Steuerelements verfügbar sein – zum Beispiel das Öffnen in der jeweiligen Zielanwendung, das Löschen einer Datei oder auch das Navigieren in unter- oder übergeordneten Verzeichnissen.<\/b><\/p>\n
Wenn wir Ordner und Dateien in einem ListView<\/b>-Steuerelement anzeigen wollen, haben wir verschiedene Möglichkeiten, diese Elemente einzulesen. Wir können diese in einer Tabellenstruktur mit Tabellen für Verzeichnisse und Dateien speichern und diese Daten in das ListView<\/b>-Steuerelement einlesen oder einfach die Daten direkt aus dem Verzeichnis holen.<\/p>\n
Da wir immer nur die Dateien aus einem Verzeichnis anzeigen wollen und davon ausgehen, dass es sich dabei nicht um Hunderte Elementen handelt, gehen wir den letzteren Weg und lesen die Elemente einfach direkt aus dem Dateisystem ein.<\/p>\n
Wir benötigen also keine Tabellen, um die Elemente zwischenzuspeichern, sondern holen diese immer beim Anzeigen eines Datensatzes. So ist auch sichergestellt, dass wir den aktuellen Dateibestand anzeigen.<\/p>\n
Daher fügen wir der Beispielanwendung nur die beiden Tabellen aus Bild 1 hinzu. Die Tabelle tblProdukte <\/b>enthält als wichtigste Information das Verzeichnis, in dem sich die Dateien zum jeweiligen Produkt befinden.<\/p>\n
![\"Tabellen](\"..\/fileadmin\/_temp_\/2025_06\/pic_493_001.png\")
<\/p>\n
Bild 1: Tabellen der Beispielanwendung<\/span><\/b><\/p>\n Anschließend legen wir ein neues, leeres Formular namens frmProdukte <\/b>in der Entwurfsansicht an.<\/p>\n Diesem weisen wir über die Eigenschaft Datensatzquelle die Tabelle tblProdukte <\/b>hinzu und ziehen alle Felder dieser Tabelle aus der Feldliste in den Formularentwurf. <\/p>\n Die Felder ordnen wir anschließend wie in Bild 2 an. Das Textfeld Verzeichnis <\/b>versehen wir mit dem Namen txtVerzeichnis<\/b>, außerdem fügen wir neben diesem eine Schaltfläche zum Auswählen des Verzeichnisses hinzu.<\/p>\n Bild 2: Das Formular frmProdukte<\/span><\/b><\/p>\n Für das Textfeld txtVerzeichnis <\/b>stellen wir die Eigenschaft Horizontaler Anker <\/b>auf Beide <\/b>ein, für die Schaltfläche cmdOrdnerauswahl <\/b>auf Rechts <\/b>und für das Bezeichnungsfeld des Textfeldes auf Links<\/b>. Dadurch vergrößert sich das Textfeld, wenn wir die Breite des Formulars vergrößern.<\/p>\n Für die Schaltfläche hinterlegen wir die Prozedur aus Listing 1.<\/p>\n Listing 1: Prozedur zum Auswählen des Ordners für das aktuelle Produkt<\/span><\/b><\/p>\n Diese Prozedur prüft, ob bereits ein Verzeichnis im Textfeld gespeichert ist. Falls ja, wird es der Variablen strInitialFolder <\/b>zugewiesen, anderenfalls erhält strInitialFolder <\/b>den Pfad zur aktuellen Datenbank (CurrentProject.Path<\/b>).<\/p>\n Danach ruft die Prozedur die Funktion ChooseFolder <\/b>auf und übergibt dieser den Wert der Variablen strInitialFolder <\/b>als Parameter.<\/p>\n Diese verwendet den eingebauten Office-Dialog zum Auswählen von Verzeichnissen. Dazu benötigen wir einen Verweis auf die Bibliothek Microsoft Office 16.0 Object Library<\/b>, den wir über den Verweise<\/b>-Dialog hinzufügen (siehe Bild 3).<\/p>\n Bild 3: Verweis auf die Office-Bibliothek<\/span><\/b><\/p>\n Die Funktion ChooseFolder <\/b>deklariert eine Objektvariable auf Basis der FileDialog<\/b>-Klasse und eine Variable zum Zwischenspeichern des gewählten Verzeichnisses (siehe Listing 2).<\/p>\n Listing 2: Funktion zum Auswählen eines Ordners<\/span><\/b><\/p>\n Dann weisen wir der Variablen eine Instanz der Klasse FileDialog <\/b>zu und übergeben dabei den Parameter msoFileDialogFolderPicker<\/b>. Dann tragen wir die Werte für die Eigenschaften Title<\/b>, ButtonName <\/b>und InitialFilename <\/b>ein und rufen die Methode Show <\/b>auf, um den Dialog anzuzeigen.<\/p>\n Der Code stoppt an dieser Stelle, bis der Benutzer ein Verzeichnis ausgewählt hat, und liest dann das gewählte Verzeichnis aus. Dieses liefert die Funktion schließlich als Ergebnis zurück, sodass das gewählte Verzeichnis von der aufrufenden Prozedur in das Textfeld txtVerzeichnis <\/b>eingetragen werden kann.<\/p>\n Nun fügen wir unterhalb der bisher angelegten Steuerelemente ein ListView<\/b>-Steuerelement ein. Dazu wählen wir im Ribbon den Befehl Formularentwurf|Steuerelemente|ActiveX-Steuerelemente <\/b>aus. Im folgenden Dialog selektieren wir den Eintrag Microsoft ListView Control, version 6.0<\/b> (siehe Bild 4), klicken auf OK <\/b>und passen anschließend die Größe des Steuerlements so an, dass es die vollständige Formularbreite einnimmt.<\/p>\n Bild 4: ListView-Steuerelement hinzufügen<\/span><\/b><\/p>\n Für das ListView<\/b>-Steuerelement legen wir den Namen ctlListView<\/b> fest.<\/p>\n Außerdem fügen wir auf dem gleichen Weg ein ImageList<\/b>-Steuerelement zum Formular hinzu und nennen es ctlImageList<\/b>.<\/p>\n Wir wollen im ListView<\/b>-Steuerelement zunächst zwei Spalten anzeigen. Die erste soll das Icon der Anwendung enthalten, mit der die jeweilige Datei standardmäßig geöffnet wird, die zweite den Dateinamen.<\/p>\n Diese Bilder müssen wir allerdings erst einmal ermitteln. Am besten wäre es, wenn diese in der Tabelle MSysResources <\/b>landen, wo wir sie mit wenigen Codezeilen auslesen und dem ImageList<\/b>-Steuerelement zuweisen können. Die größere Herausforderung ist jedoch, die Bilder für die verschiedenen Dateitypen zu erhalten.<\/p>\n Wie das gelingt, haben wir in einem eigenen Artikel namens VBA: Datei-Icons einlesen und speichern <\/b>(www.vbentwickler.de\/2<\/b>) beschrieben.<\/p>\n Das Ergebnis der dort beschriebenen Techniken ist eine Funktion namens SaveFileIconToMSysResources<\/b>, der wir den Namen der Datei, deren Icon wir erhalten wollen, und einige weitere Informationen übergeben. Als Ergebnis landen die gewünschten Dateien wie in Bild 5 in der Tabelle MSysResources<\/b>.<\/p>\n Bild 5: Die Tabelle mit den Datei-Icons<\/span><\/b><\/p>\n Die Dateien sollen immer beim Anzeigen eines Datensatzes im Formular frmProdukte <\/b>in das ListView<\/b>-Steuerelement geladen werden.<\/p>\n Deshalb füllen wir die Prozedur, die durch das Ereignis Beim Anzeigen <\/b>ausgelöst wird, mit dem Aufruf der Funktion FillListView<\/b>, die wir im Anschluss beschreiben. Dieser Funktion übergeben wir den Pfad aus dem Feld txtVerzeichnis<\/b>:<\/p>\n Den ersten Teil der Funktion FillListView<\/b> finden wir in Listing 3. Nach dem Deklarationsteil referenzieren wir das ListView<\/b>– und das ImageList<\/b>-Steuerelement mit den Variablen objListView <\/b>und objImageList<\/b>. Dabei greifen wir jeweils über die Object<\/b>-Eigenschaft auf das eigentliche ActiveX-Objekt zu, um mit allen Eigenschaften und Methoden der MSComctl<\/b>-Steuerelemente arbeiten zu können.<\/p>\n Listing 3: Funktion zum Füllen des ListView-Steuerelements, Teil 1<\/span><\/b><\/p>\n Dann schalten wir das Neuzeichnen des Formulars aus, bis das ListView<\/b>-Steuerelement vollständig gefüllt ist. Für das ListView<\/b>-Steuerelement nehmen wir anschließend einige grundlegende Einstellungen vor.<\/p>\n Diese könnte man teilweise auch direkt im Eigenschaftenblatt des Steuerelements setzen. Da wir jedoch in vielen Formularen identische Einstellungen benötigen, haben wir uns angewöhnt, diese Konfiguration per VBA vorzunehmen und bei Bedarf in andere Formularmodule zu übernehmen.<\/p>\n Auf diese Weise behalten wir die vollständige Kontrolle über das Verhalten des ListViews<\/b> im Code.<\/p>\n Bevor wir das ListView <\/b>konfigurieren, führen wir eine wichtige Initialisierung durch: Zunächst lösen wir eine eventuell bestehende Zuordnung der ImageList <\/b>zum ListView<\/b>, indem wir die Eigenschaft SmallIcons <\/b>auf Nothing <\/b>setzen.<\/p>\n Anschließend leeren wir sowohl die vorhandenen Einträge im ListView <\/b>als auch die ListImages<\/b>-Auflistung der ImageList<\/b>. Dieser Schritt ist entscheidend, da Änderungen an einer ImageList <\/b>zur Laufzeit nur dann stabil funktionieren, wenn sie nicht gleichzeitig von einem ListView<\/b>-Steuerelement verwendet wird.<\/p>\n Da einige Versionen des ListView<\/b>-Steuerelements keine vollständig leere ImageList <\/b>akzeptieren, fügen wir anschließend mindestens ein Icon in die ImageList <\/b>ein. In diesem Fall laden wir ein Ordner-Icon mit dem Namen lvw_folder <\/b>aus der Tabelle MSysResources <\/b>in die ImageList<\/b>. Erst danach weisen wir die ImageList <\/b>wieder dem ListView <\/b>zu, indem wir die Eigenschaft SmallIcons <\/b>entsprechend setzen.<\/p>\n Nun konfigurieren wir das ListView<\/b>-Steuerelement. Dabei legen wir unter anderem die Darstellungsart, Schriftart und -größe sowie das Auswahlverhalten fest.<\/p>\n Wichtig ist an dieser Stelle auch das Einfügen der beiden Spaltenüberschriften: Zum einen eine leere Zeichenkette für die erste Spalte, in der später ausschließlich die Icons angezeigt werden, und zum anderen die Überschrift Dateiname <\/b>für die zweite Spalte, in der die Namen der Dateien und Ordner erscheinen.<\/p>\n Anschließend prüfen wir, ob der Parameter strFolder <\/b>nicht leer ist, also ob ein Verzeichnis übergeben wurde. Ist dies der Fall, stellen wir zunächst sicher, dass der Pfad mit einem Backslash (\\<\/b>) endet. Fehlt dieser, wird er ergänzt, damit sich die weiteren Pfadangaben korrekt zusammensetzen lassen.<\/p>\n Danach ermitteln wir mit der Dir<\/b>-Funktion das erste Element im angegebenen Verzeichnis und speichern dessen Namen in der Variablen strElement<\/b>. Dabei übergeben wir explizit den Parameter vbDirectory<\/b>, um neben Dateien auch Verzeichnisse zu berücksichtigen.<\/p>\n Anschließend beginnt eine Do While<\/b>-Schleife, die so lange durchlaufen wird, bis Dir <\/b>eine leere Zeichenkette zurückliefert (siehe Listing 4).<\/p>\n Listing 4: Funktion zum Füllen des ListView-Steuerelements, Teil 2<\/span><\/b><\/p>\n Innerhalb der Schleife setzen wir zunächst den vollständigen Pfad aus strFolder <\/b>und strElement <\/b>zusammen und speichern ihn in strPath<\/b>.<\/p>\n Danach prüfen wir anhand der Dateiattribute, ob es sich bei dem aktuellen Element um ein Verzeichnis handelt. Ist dies der Fall, verwenden wir direkt das zuvor geladene Ordner-Icon lvw_folder<\/b>. Dieses Icon muss zuvor manuell oder programmatisch in der Tabelle MSysResources <\/b>hinterlegt worden sein.<\/p>\n Handelt es sich dagegen um eine Datei, ermitteln wir zunächst die Dateiendung und speichern sie in strExtension<\/b>. Aus der Zeichenkette ico_ <\/b>und der Dateiendung setzen wir anschließend den Namen des zu verwendenden Icons zusammen, zum Beispiel png_ico<\/b>, und speichern ihn in strIcon<\/b>.<\/p>\n Da beim Arbeiten mit ImageList<\/b>-Elementen zwischen Groß- und Kleinschreibung unterschieden wird, werden die Namen der Icons konsequent in Kleinbuchstaben gespeichert.<\/p>\n Im nächsten Schritt prüfen wir, ob es in der Tabelle MSysResources <\/b>bereits einen Eintrag mit dem Namen aus strIcon <\/b>gibt, das entsprechende Icon also schon gespeichert ist. Ist dies nicht der Fall, rufen wir die im Artikel beschriebene Prozedur SaveFileIconToMSysResources <\/b>auf, um das Icon aus der Datei zu extrahieren und in MSysResources <\/b>abzulegen.<\/p>\n Anschließend durchlaufen wir in einer For…Next<\/b>-Schleife alle bisher in der ImageList <\/b>vorhandenen ListImage<\/b>-Einträge und prüfen, ob das benötigte Icon dort bereits enthalten ist.<\/p>\n Dazu initialisieren wir zunächst die Variable bolVorhanden <\/b>mit dem Wert False<\/b>. Stimmen der Key eines vorhandenen ImageList<\/b>-Eintrags und der Wert aus strIcon <\/b>überein, ist das Icon bereits vorhanden. In diesem Fall setzen wir bolVorhanden <\/b>auf True <\/b>und verlassen die Schleife.<\/p>\n Ist bolVorhanden <\/b>nach Abschluss der Schleife weiterhin False<\/b>, wurde das Icon bislang noch nicht in die ImageList <\/b>geladen. Wir fügen es dann mit der Prozedur amvAddIconToImageListFromResourcesByName <\/b>hinzu.<\/p>\n Nun folgt das eigentliche Einfügen der Elemente in das ListView<\/b>-Steuerelement. Zunächst prüfen wir, ob Dir <\/b>nicht die beiden speziellen Einträge . <\/b>oder .. <\/b>zurückgegeben hat, da diese nicht im ListView <\/b>angezeigt werden sollen.<\/p>\n Anschließend erhöhen wir den Zähler lngElement<\/b>, der als Bestandteil des eindeutigen Keys für die ListView<\/b>-Einträge dient, und fügen das neue Element mit der Add<\/b>-Methode der ListItems<\/b>-Auflistung hinzu.<\/p>\n Als anzuzeigenden Text übergeben wir eine leere Zeichenkette, sodass in der ersten Spalte ausschließlich das Icon erscheint. Über den fünften Parameter geben wir den Namen des Icons an, das aus der ImageList <\/b>verwendet werden soll.<\/p>\n Den eigentlichen Dateinamen fügen wir in der zweiten Spalte hinzu. Dies geschieht über die Add<\/b>-Methode der ListSubItems<\/b>-Auflistung des soeben angelegten ListView<\/b>-Eintrags. Als Key verwenden wir erneut eine Kombination aus einem festen Buchstaben und dem aktuellen Zählerwert, als Text den Inhalt von strElement<\/b>.<\/p>\n Zum Abschluss der Schleife rufen wir erneut die Dir<\/b>-Funktion auf, um das nächste Element im Verzeichnis zu ermitteln. Nach dem vollständigen Durchlaufen aller Dateien und Ordner passen wir mit der Prozedur AutoSizeListViewColumns <\/b>die Spaltenbreiten an den Inhalt an und markieren das erste ListView<\/b>-Element als ausgewählt.<\/p>\n Abschließend aktivieren wir das Neuzeichnen des Formulars wieder, indem wir die Eigenschaft Me.Painting <\/b>auf True <\/b>setzen.<\/p>\n Hinweis: <\/b>Wir haben die Prozedur in der Beispieldatenbank später noch einmal so angepasst, dass zuerst die Ordner und dann erst die Dateien angezeigt werden – beides in alphabetischer Reihenfolge.<\/p>\n Die zuvor erwähnte Prozedur amvAddIconToImageListFromResourcesByName <\/b>wird für jedes Icon aufgerufen, das noch nicht in der ImageList <\/b>enthalten ist. Wie diese funktioniert, zeigen wir in einem weiteren Artikel namens Icons aus MSysResources in ImageList einfügen <\/b>(www.vbentwickler.de\/7<\/b>).<\/p>\n Das ListView<\/b>-Steuerelement soll nun zu verschiedenen Zeitpunkten aktualisiert werden, und zwar beim Anzeigen eines neuen Datensatzes und nach dem Auswählen des jeweiligen Ordners.<\/p>\n Damit dies beim Anzeigen eines Datensatzes geschieht, haben wir den Aufruf bereits der Prozedur Form_Current <\/b>hinzugefügt.<\/p>\n Außerdem ergänzen wir die Ereignisprozedur cmdOrdnerauswahl_Click <\/b>um diese Anweisung:<\/p>\n Nun wollen wir dem ListView<\/b>-Steuerelement weitere Funktionen hinzufügen, zum Beispiel die folgenden:<\/p>\n Vorbereitend auf verschiedene Aktionen legen wir eine Variable im Kopf des Klassenmoduls des Formulars an, in der wir den aktuell angezeigten Pfad speichern:<\/p>\n Wenn wir zu einem unter- oder übergeordneten Verzeichnis springen, also das in txtVerzeichnis <\/b>angegebene Verzeichnis verlassen, benötigen wir für spätere Operationen wie ein weiteres Navigieren zu über- oder untergeordneten Verzeichnissen das aktuelle Verzeichnis.<\/p>\n Den Wert dieser Variablen stellen wir erstmalig in der Prozedur Form_Current <\/b>ein:<\/p>\n Auch die Prozedur cmdOrdnerauswahl_Click<\/b> erweitern wir um diese Anweisung:<\/p>\n Ein Doppelklick auf ein Element soll je nach dem angeklickten Element entweder den Unterordner öffnen oder das Element in der jeweiligen Anwendung anzeigen.<\/p>\n Das erledigen wir mit der Ereignisprozedur DblClick <\/b>des ListView<\/b>-Steuerelements. Dieses können wir nicht wie gewohnt über das Eigenschaftenblatt anlegen, sondern wir müssen im VBA-Editor im Codefenster im linken Kombinationsfeld den Eintrag ctlListView <\/b>und im rechten das Ereignis DblClick <\/b>auswählen. Dies legt die leere Prozedur an, die wir nun wie folgt füllen:<\/p>\n Die Prozedur referenziert das ListView<\/b>-Steuerelement mit der Variablen objListView<\/b>, allerdings nicht direkt, sondern über die Object<\/b>-Eigenschaft – ctlListView <\/b>selbst ist nur ein CustomControl<\/b>-Element, das seinerseits das ListView<\/b>-Steuerelement enthält.<\/p>\n Dann prüfen wir, ob der in strCurrentFolder <\/b>gespeicherte Wert bereits ein abschließendes Backslash-Zeichen enthält, und fügen dieses gegebenenfalls noch hinzu. Danach referenzieren wir mit objListItem <\/b>das aktuell markierte Element des ListView<\/b>-Steuerelements.<\/p>\n Darüber können wir allerdings noch nicht den angezeigten Ordner oder die Datei ermitteln, sondern benötigen dazu noch das ListSubItem<\/b>-Element. Hier referenzieren wir mit objListSubItem <\/b>das erste Element der ListSubItems<\/b>-Auflistung.<\/p>\n Schließlich lesen wir daraus über die Text<\/b>-Eigenschaft den angezeigten Text aus und schreiben ihn zusammen mit dem aktuellen Verzeichnis aus strCurrentFolder <\/b>in strPath<\/b>.<\/p>\n Für den Pfad prüfen wir nun, ob es sich um ein Verzeichnis oder um eine Datei handelt. Im Falle eines Verzeichnisses rufen wir einfach die Prozedur FillListView<\/b> auf und übergeben den nun aktuellen Pfad.<\/p>\n Da wir nun ein anderes Verzeichnis als zuvor anzeigen, speichern wir den aktuellen Pfad auch noch in strCurrentFolder<\/b>.<\/p>\n Schließlich rufen wir noch die Prozedur SteuerelementeAktualisieren <\/b>auf, die prüft, ob wir beim Navigieren zum übergeordneten Verzeichnis bereits beim Hauptordner wie c:\\ <\/b>angekommen sind. In diesem Fall deaktivieren wir die Schaltfläche cmdUebergeordnetes <\/b>Verzeichnis, damit kein Fehler auftritt:<\/p>\n Falls es sich bei dem angeklickten Eintrag um eine Datei handelt, öffnen wir diese mit der Funktion FollowHyperlink<\/b>, der wir dieses Mal den Pfad zur Datei übergeben und diese damit mit der im System für diesen Dateityp hinterlegten Anwendung öffnen.<\/p>\n Um das übergeordnete Verzeichnis des aktuell angezeigten Verzeichnisses anzuzeigen, fügen wir dem Formular über dem ListView<\/b>-Steuerelement eine Schaltfläche namens cmdUebergeordnetesVerzeichnis <\/b>hinzu (siehe Bild 6).<\/p>\n Bild 6: Neue Schaltfläche zum Anzeigen des übergeordneten Verzeichnisses<\/span><\/b><\/p>\n Für diese Schaltfläche hinterlegen wir die folgende Ereignisprozedur:<\/p>\n Diese ermittelt zunächst den aktuellen Ordner aus strCurrentFolder<\/b>.<\/p>\n Dann prüft sie, ob das letzte Zeichen ein Backslash ist, und ergänzt diesen gegebenenfalls. Danach rufen wir die Prozedur FillListView <\/b>auf, um die Dateien des übergeordneten Verzeichnisses anzuzeigen.<\/p>\n Schließlich stellen wir strCurrentFolder <\/b>auf den nun angezeigten Ordner ein, schreiben diesen in das Textfeld txtAktuellerOrdner<\/b>, das wir zwischenzeitlich unterhalb des ListView<\/b>-Steuerelements angelegt haben, und rufen erneut die Prozedur SteuerelementeAktualisieren <\/b>auf.<\/p>\n Dieser Artikel zeigt, wie wir den Inhalt eines vollständigen Verzeichnisses in ein ListView<\/b>-Steuerelement einlesen. Dabei weisen wir direkt die Icons der Anwendung für die jeweilige Datei hinzu oder ein Ordner-Symbol für Verzeichnisse. Der aktuelle Stand sieht nun wie in Bild 7 aus.<\/p>\n Bild 7: Aktueller Stand des Datei-Formulars<\/span><\/b><\/p>\n Es gibt noch einige Erweiterungsmöglichkeiten:<\/p>\nFormular der Anwendung<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2025_06\/pic_493_002.png\")
<\/p>\nOrdner auswählen<\/h2>\n
Private Sub <\/span>cmdOrdnerauswahl_Click()\r\n Dim <\/span>strInitialFolder As String<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(Nz(Me.txtVerzeichnis, 0)) = 0 Then<\/span>\r\n strInitialFolder = CurrentProject.Path\r\n Else<\/span>\r\n strInitialFolder = Me.txtVerzeichnis\r\n End If<\/span>\r\n Me.txtVerzeichnis = ChooseFolder(strInitialFolder)\r\nEnd Sub<\/span><\/pre>\n![\"Verweis](\"..\/fileadmin\/_temp_\/2025_06\/pic_493_003.png\")
<\/p>\nPublic Function <\/span>ChooseFolder(strInitialFolder As String<\/span>)\r\n Dim <\/span>objFileDialog As <\/span>Office.FileDialog\r\n Dim <\/span>strTemp As String<\/span>\r\n Set<\/span> objFileDialog = Application.FileDialog(msoFileDialogFolderPicker)\r\n With<\/span> objFileDialog\r\n .Title = \"Verzeichnis auswählen\"\r\n .ButtonName = \"Auswählen\"\r\n .InitialFilename = strInitialFolder\r\n If <\/span>.Show = True<\/span> Then<\/span>\r\n strTemp = .SelectedItems(1)\r\n End If<\/span>\r\n End With<\/span>\r\n ChooseFolder = strTemp\r\nEnd Function<\/span><\/pre>\nListView zur Anzeige der Ordner und Dateien hinzufügen<\/h2>\n
![\"ListView-Steuerelement](\"..\/fileadmin\/_temp_\/2025_06\/pic_493_005.png\")
<\/p>\nImageList zum Speichern von Icons hinzufügen<\/h2>\n
Icons einlesen<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2025_06\/pic_493_004.png\")
<\/p>\nDateien in das ListView-Steuerelement einlesen<\/h2>\n
Private Sub <\/span>Form_Current()\r\n Call<\/span> FillListView(Nz(Me.txtVerzeichnis, \"\"))\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>FillListView(strFolder As String<\/span>)\r\n Dim <\/span>objListView As <\/span>MSComctlLib.ListView\r\n Dim <\/span>objListItem As <\/span>MSComctlLib.ListItem\r\n Dim <\/span>objImageList As <\/span>MSComctlLib.ImageList\r\n Dim <\/span>strElement As String<\/span>\r\n Dim <\/span>lngElement As Long<\/span>\r\n Dim <\/span>strExtension As String<\/span>\r\n Dim <\/span>lngListImage As Long<\/span>\r\n Dim <\/span>bolVorhanden As Boolean<\/span>\r\n Dim <\/span>strPath As String<\/span>\r\n Dim <\/span>strIcon As String<\/span>\r\n \r\n Set<\/span> objListView = Me.ctlListView.Object\r\n Set<\/span> objImageList = Me.ctlImageList.Object\r\n \r\n Me.Painting = False<\/span>\r\n \r\n Set<\/span> objListView.SmallIcons = Nothing\r\n objListView.ListItems.Clear\r\n objImageList.ListImages.Clear\r\n \r\n amvAddIconToImageListFromResourcesByName objImageList, \"lvw_folder\"\r\n \r\n With<\/span> objListView\r\n .Appearance = ccFlat\r\n .BorderStyle = ccNone\r\n .Font.Name = \"Calibri\"\r\n .Font.Size = 10\r\n .View = lvwReport\r\n .FullRowSelect = True<\/span>\r\n .HideSelection = False<\/span>\r\n .SmallIcons = objImageList\r\n .ColumnHeaders.Clear\r\n .ColumnHeaders.Add , \"c0\", \"\"\r\n .ColumnHeaders.Add , \"c1\", \"Dateiname\"\r\n End With<\/span>\r\n \r\n objListView.ListItems.Clear\r\n \r\n If <\/span>Not<\/span> Len<\/span>(strFolder) = 0 Then<\/span>\r\n If <\/span>Not<\/span> Right<\/span>(strFolder, 1) = \"\\\" Then<\/span>\r\n strFolder = strFolder & \"\\\"\r\n End If<\/span>\r\n \r\n strElement = Dir(strFolder, vbDirectory)\r\n ...<\/pre>\n ...\r\n Do While<\/span> Not<\/span> Len<\/span>(strElement) = 0\r\n strPath = strFolder & strElement\r\n If <\/span>(GetAttr(strPath) And vbDirectory) = vbDirectory Then<\/span>\r\n strIcon = \"lvw_folder\"\r\n Else<\/span>\r\n strExtension = Mid<\/span>(strElement, InStrRev<\/span>(strElement, \".\") + 1)\r\n strIcon = LCase(\"ico_\" & strExtension)\r\n If <\/span>IsNull(DLookup(\"name\", \"MSysResources\", \"name=''\" & strIcon & \"''\")) Then<\/span>\r\n Call<\/span> SaveFileIconToMSysResources(strPath, strIcon, True<\/span>)\r\n End If<\/span>\r\n \r\n bolVorhanden = False<\/span>\r\n For lngListImage = 1 To objImageList.ListImages.Count\r\n If <\/span>objImageList.ListImages.Item(lngListImage).Key = strIcon Then<\/span>\r\n bolVorhanden = True<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> lngListImage\r\n \r\n If <\/span>bolVorhanden = False<\/span> Then<\/span>\r\n amvAddIconToImageListFromResourcesByName objImageList, strIcon\r\n End If<\/span>\r\n End If<\/span>\r\n If <\/span>Not<\/span> (strElement = \".\" Or strElement = \"..\") Then<\/span>\r\n lngElement = lngElement + 1\r\n Set<\/span> objListItem = objListView.ListItems.Add(, \"i\" & lngElement, \"\", , strIcon)\r\n With<\/span> objListItem.ListSubItems\r\n .Add , \"a\" & lngElement, strElement\r\n End With<\/span>\r\n End If<\/span>\r\n strElement = Dir\r\n Loop<\/span>\r\n \r\n AutoSizeListViewColumns objListView, True<\/span>\r\n If <\/span>Not<\/span> objListView.ListItems.Count = 0 Then<\/span>\r\n objListView.SelectedItem = objListView.ListItems(1)\r\n End If<\/span>\r\n End If<\/span>\r\n \r\n Me.Painting = True<\/span>\r\n \r\nEnd Sub<\/span><\/pre>\nProzedur zum Eintragen der Icons in das ImageList-Steuerelement<\/h2>\n
Aktualisierung des ListView-Steuerelements <\/h2>\n
Private Sub <\/span>cmdOrdnerauswahl_Click()\r\n ... \r\n Call<\/span> FillListView(Me.txtVerzeichnis)\r\nEnd Sub<\/span><\/pre>\nWeitere Funktionen<\/h2>\n
\n
Private <\/span>strCurrentFolder As String<\/span><\/pre>\nPrivate Sub <\/span>Form_Current()\r\n ...\r\n strCurrentFolder = Me.txtVerzeichnis\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Current()\r\n Call<\/span> FillListView(Nz(Me.txtVerzeichnis, \"\"))\r\n strCurrentFolder = Nz(Me.txtVerzeichnis, \"\")\r\nEnd Sub<\/span><\/pre>\nÖffnen einer Datei oder eines Unterordners per Doppelklick<\/h2>\n
Private Sub <\/span>ctlListView_DblClick()\r\n Dim <\/span>objListView As <\/span>MSComctlLib.ListView\r\n Dim <\/span>objListItem As <\/span>MSComctlLib.ListItem\r\n Dim <\/span>objListSubItem As <\/span>MSComctlLib.ListSubItem\r\n Dim <\/span>strFile As String<\/span>\r\n Dim <\/span>strPath As String<\/span>\r\n \r\n Set<\/span> objListView = Me.ctlListView.Object\r\n If <\/span>Not<\/span> Right<\/span>(Trim<\/span>(strCurrentFolder), 1) = \"\\\" Then<\/span>\r\n strCurrentFolder = strCurrentFolder & \"\\\"\r\n End If<\/span>\r\n Set<\/span> objListItem = objListView.SelectedItem\r\n Set<\/span> objListSubItem = objListItem.ListSubItems(1)\r\n strPath = strCurrentFolder & objListSubItem.Text\r\n If <\/span>(GetAttr(strPath) And vbDirectory) = vbDirectory Then<\/span>\r\n Call<\/span> FillListView(strPath)\r\n strCurrentFolder = strPath\r\n Me.txtAktuellerOrdner = strCurrentFolder\r\n Call<\/span> SteuerelementeAktualisieren\r\n Else<\/span>\r\n Call<\/span> FollowHyperlink(strPath)\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>SteuerelementeAktualisieren()\r\n If Len<\/span>(strCurrentFolder) - _\r\n Len<\/span>(Replace<\/span>(strCurrentFolder, \"\\\", \"\")) < 2 Then\r\n Me.cmduebergeordnesVerzeichnis.Enabled = False<\/span>\r\n Else<\/span>\r\n Me.cmduebergeordnesVerzeichnis.Enabled = True<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nAnzeigen des übergeordneten Verzeichnisses<\/h2>\n
![\"Neue](\"..\/fileadmin\/_temp_\/2025_06\/pic_493_006.png\")
<\/p>\nPrivate Sub <\/span>cmduebergeordnesVerzeichnis_Click()\r\n Dim <\/span>strFolder As String<\/span>\r\n strFolder = Trim<\/span>(strCurrentFolder)\r\n If <\/span>Right<\/span>(strFolder, 1) = \"\\\" Then<\/span>\r\n strFolder = Left<\/span>(strFolder, Len<\/span>(strFolder) - 1)\r\n End If<\/span>\r\n strFolder = Left<\/span>(strFolder, InStrRev<\/span>(strFolder, \"\\\"))\r\n Call<\/span> FillListView(strFolder)\r\n strCurrentFolder = strFolder\r\n Me.txtAktuellerOrdner = strCurrentFolder\r\n Call<\/span> SteuerelementeAktualisieren\r\nEnd Sub<\/span><\/pre>\nZusammenfassung und Ausblick<\/h2>\n
![\"Aktueller](\"..\/fileadmin\/_temp_\/2025_06\/pic_493_007.png\")
<\/p>\n\n