<\/p>\n
In Access-Datenbanken werden ja nicht immer nur Personen, Objekte und Vorgänge verwaltet. Nicht selten lesen Sie auch Dateien und deren Eigenschaften in Tabellen ein. Denken Sie etwa an die Informationen, die Sie Audio- oder Videodateien für eine Medienverwaltung abringen möchten. Mit dem Rüstzeug von VBA allein kommen Sie hier nicht weit, wohl aber mit den Shell-Objekten von Windows.<\/b><\/p>\nDateieigenschaften im Explorer<\/h2>\n
Der Explorer<\/b> von Windows zeigt einige Eigenschaften von Dateien in voreingestellten Spalten an, wenn Sie die Detailansicht auswählen. Welche das sind, hängt vom Ordnerinhalt ab, den Windows vermutet. Für allgemeine Dateien sind das neben dem Namen in der Regel noch der Dateityp<\/b>, die Größe<\/b>, sowie änderungs<\/b>– und Erstelldatum<\/b>. Befinden sich jedoch etwa eine größere Anzahl von JPEG<\/b>-Dateien im Verzeichnis, so wechselt der Explorer das Spalten-Set in mehr oder weniger für Bilder nützliche Informationen. <\/p>\n
Mit Rechtsklick auf die Spaltenköpfe erscheint ein Popup-Menü, über das Sie andere gebräuchliche Spalten an- oder abwählen können (siehe Bild 1).<\/p>\n
![\"Popup](\"..\/fileadmin\/_temp_\/2018_02\/ExplorerPopup.png\")
<\/p>\n
Bild 1: Popup des Explorer-Spaltenkopfs<\/span><\/b><\/p>\n Benötigen Sie andere Informationen, so erscheint über Weitere…<\/b> der Dialog in Bild 2, in dem Sie aus einer umfangreichen Liste die gewünschten Einträge markieren, wobei viele nur bestimmten Dateitypen vorbehalten sind, weshalb die dann eingeblendeten Spalten im Zweifel leer bleiben. Das eingestellte Spalten-Set speichert die Windows-Shell<\/b> pro Ordner persistent, sobald Sie ihn verlassen.<\/p>\n Bild 2: Liste der Dateieigenschaften im Details-Dialog des Explorer für Ordner<\/span><\/b><\/p>\n Klicken Sie auf eine Datei rechts und wählen im Kontextmenü den Eintrag Eigenschaften<\/b>, so bekommen Sie unter dem Reiter Details<\/b> allerlei Informationen präsentiert, die sich je nach Dateityp in Inhalt und Umfang unterscheiden (siehe Bild 3).<\/p>\n Bild 3: Informationen zu einer MP3-Datei im Eigenschaftendialog des Explorers<\/span><\/b><\/p>\n Der Name einer Eigenschaft ist dabei jeweils identisch zu jenem, der auch im anderen Dialog oder in den Spaltenköpfen angezeigt wird. Das Gleiche gilt für die Werte. Einige Eigenschaften sind hier sogar editierbar, wenn sich das Wertefeld beim Markieren in eine Textbox verwandelt.<\/p>\n Wir haben es hier überall mit dem sogenannten Property System<\/b> von Windows zu tun, das in die Shell<\/b> integriert ist. Und auf dieses können Sie mithilfe einiger Objekte auch in Ihrem VBA-Projekt zugreifen! Der Aufwand dafür hält sich in Grenzen. Es werden im Prinzip nämlich keine jener API<\/b>-Funktionen benötigt, die man sonst häufig in entsprechenden Routinen zum Auslesen von Dateieigenschaften im Netz findet.<\/p>\n Es wurde in der jetzigen Form mit Windows Vista<\/b> eingeführt und dient der Abstraktion von Dateieigenschaften im System. über die Ansprache einer einzigen Komponente (propsys.dll<\/b>) können alle verfügbaren Informationen abgerufen werden. Diese Komponente bemüht ihrerseits andere Komponenten, die die eigentliche Arbeit verrichten, weil nur sie den Aufbau bestimmter Dateitypen kennen. Und außerdem kann das Property System<\/b> noch durch installierte Programme erweitert werden. Office<\/b> installiert etwa zusätzliche solcher Property Handler<\/b>, damit Sie direkt auf Dokumenteigenschaften zugreifen können, ohne eines der Programme starten zu müssen. Dafür gibt es eine festgelegte Schnittstelle. Welche Dateitypen mit welchen Komponenten korrelieren, wird dabei in der Registry<\/b> festgehalten.<\/p>\n Die Demo zu diesem Beitrag (FileProps.accdb<\/b>) enthält alles Nötige für den Umgang mit diesen Dateieigenschaften. Sie können Teile aus ihr problemlos in eigene Projekte übertragen.<\/p>\n Grundvoraussetzung ist zunächst ein Verweis<\/b> auf die Bibliothek Microsoft Shell Controls And Automation<\/b> im VBA-Projekt, die sich dann im Objektkatalog als Shell32<\/b> zeigt. Die Bibliothek bringt Windows immer mit und kann deshalb ganz ohne Gewissensbisse eingesetzt werden.<\/p>\n Die Prozedur SHGetPropertyString<\/b> im Modul mdlPropsShell<\/b> macht sich dann einige Klassenobjekte der Bibliothek zunutze. Mit gerade einmal 20 Zeilen Code erledigt sie das Auslesen beliebiger Datei- und Ordnereigenschaften, die von der Shell unterstützt werden – und das sind eine ganze Menge! Listing 1 zeigt die komplette Routine. Sie übergeben der Funktion im ersten Parameter den vollen Pfad der Datei und im zweiten die gewünschte Eigenschaft. Zurück erhalten Sie dann grundsätzlich den Wert der Eigenschaft als String. Dies wäre ein Beispiel:<\/p>\n Listing 1: Die Funktion gibt eine beliebige Dateieigenschaft zurück<\/span><\/b><\/p>\n Hier wird die Dateigröße der MP3-Datei ermittelt. Setzen Sie als zweiten Parameter System.DateCreated<\/b> ein, so erhielten Sie das Erstelldatum:<\/p>\n Oder mit System.FileOwner<\/b> den Besitzer der Datei:<\/p>\n Was es mit diesen Property<\/b>-Parametern auf sich hat und wie man auf sie kommt, erläutern wir später noch. Hier folgt aber zunächst die Funktionsweise des Codes.<\/p>\n Das zentrale Objekt, von dem sich alles Weitere ableitet, steht in der Objektvariablen oSH<\/b> vom Typ Shell<\/b>, die im Modulkopf global deklariert ist. Dieses Objekt kann per New<\/b> erzeugt werden. Eine Alternative, die ganz ohne Bibliotheksverweis auskommt, wäre<\/p>\n Bevor das Objekt benutzt wird, müssen aber aus dem vollen Pfad in sFile<\/b> erst der Ordner- und der Dateinamenanteil extrahiert werden, was die folgenden zwei Zeilen erledigen. sFld<\/b> enthält danach den Ordner, sFil<\/b> den Dateinamen. Um beim vorigen Beispiel zu bleiben:<\/p>\n Die NameSpace<\/b>-Funktion des Shell<\/b>-Objekts gibt nun ein neues Objekt vom Typ Folder<\/b> in oFld<\/b> zurück, wenn man den Pfad übergibt, der hier zusätzlich mit CStr<\/b> behandelt wird. Manchmal funktioniert die übergabe eines VBA-Strings hier nämlich nicht korrekt und CStr<\/b> stellt sicher, dass die Funktion einen gültigen COM-String erhält.<\/p>\n Der Clou an der Routine ist, dass Sie ihr nicht nur Dateien, sondern auch Ordner zur Inspektion verabreichen können. In diesem Fall ist die Variable sFil<\/b> dann leer und die per Len()<\/b> ermittelte Länge 0<\/b>. Davon hängt in der Bedingung ab, wie weiter verfahren wird. Denn als nächstes wird die Items<\/b>-Auflistung des Folder-Objekts bemüht. Das ist im Prinzip das, was der Explorer auf der rechten Seite ausgibt. Ein Item<\/b> kann eine Datei im Verzeichnis sein, oder ein Unterordner. Da der Explorer auch virtuelle Objekte darstellen kann, wie etwa die Systemsteuerung, könnte ein Item<\/b> auch ein virtuelles Objekt wiederspiegeln. Selbst dessen Eigenschaften könnten mit der Routine ausgelesen werden, doch das steht hier im Beitrag gerade nicht zur Debatte.<\/p>\n Das Item<\/b> erhält die Objektvariable oItm<\/b> vom Typ ShellFolderItem<\/b>. Für eine Datei übergeben Sie als Index der Auflistung Items<\/b> den Namen in sFil<\/b>. Soll der Ordner selbst inspiziert werden, so kann er selbst in ein Item<\/b> überführt werden, wenn die Methode Self<\/b> auf den Folder<\/b> angewandt wird. Und nun sind wir soweit: Vom Item<\/b> kann die Funktion ExtendedProperty<\/b> abgerufen werden, der als Parameter der Systemname der Eigenschaft (sProp<\/b>) übergeben wird. Das Ergebnis steht nun im Variant vRet<\/b>.<\/p>\n Allerdings gibt diese Methode nicht immer nur einen String zurück, sondern manchmal auch ein ein String-Array<\/b>. Ein Word-Dokument kann etwa mehrere Autoren aufweisen, die über den Property<\/b>-Namen System.Author <\/b>ermittelt würden. Die einzelnen Autoren stünden dann als Elemente eines Arrays im Ergebnis. Die VBA-Funktion IsArray<\/b> erkennt, ob das Ergebnis ein Array ist. Dann fügt die Join<\/b>-Funktion die Elemente des Arrays zu einem einzelnen String zusammen.<\/p>\n Was Sie nun noch brauchen, um sämtliche Eigenschaften einer Datei auslesen zu können, sind die Systemnamen der Eigenschaften. Leider gibt es dafür keine generelle Liste. Denn erstens hat jede Windows-Version ihre eigenen abweichenden Systemeigenschaften, und zweitens lässt sich, wie erwähnt, das Property System<\/b> ja durch neu installierte Programme erweitern, was zu neuen in der Registry eingetragenen Property Names<\/b> führt.<\/p>\n Leider ist man mit der Shell32<\/b>-Bibliothek hier am Ende der Fahnenstange angekommen. Sie enthält keine Methoden, um an die Systemnamen zu kommen. Gottlob gibt es aber die in früheren Beträgen bereits erwähnte Type Library<\/b> oleexp<\/b>. Vorgestellt wurde sie etwa im Beitrag Explorer Control <\/b>(Shortlink 1096). Sie stellt, so Sie sie in die Verweise aufnehmen, alle Klassen und Interfaces<\/b> bereit, die für das Auslesen der Systemnamen benötigt werden.<\/p>\n Die Bibliothek wird übrigens von der Demo beim Start des Intro<\/b>-Formulars frmIntro<\/b> automatisch geladen und sollte sich dazu im Verzeichnis der Datenbank befinden:<\/p>\n Die Prozedur StorePropertyKeys<\/b> im gesonderten Modul mdlPropStore<\/b> ermittelt dann alle Systemnamen und speichert sie in der Tabelle tblSysProperties<\/b>. Um es klarzustellen: Dieses Modul brauchen Sie in Ihrer produktiven Datenbank später nicht mehr und eben so wenig den Verweis auf die Bibliothek oleexp<\/b>!<\/p>\n Es dient hier ausschließlich dazu, um die Tabelle zu füllen, die dann die gefragten Systemnamen enthält. Nur diese brauchen Sie schließlich in Ihre Datenbank zu übernehmen.<\/p>\n Der Aufbau der Tabelle ergibt sich aus Bild 4. Das Feld Systemname erhält den Property<\/b>-Namen, wie etwa System.Author<\/b>. In Bezeichnung<\/b> steht dann die deutsche übersetzung, wie Autoren<\/b>. Alle anderen Felder sind optional und nur informativ. In Type<\/b> steht der Datentyp, wie etwa String<\/b> oder Integer<\/b>.<\/p>\n Bild 4: In der Entwurfsansicht der Tabelle tblSysProperties ist das Feld Systemname eindeutig indiziert<\/span><\/b><\/p>\n Da die Methode ExtendedProperty<\/b> immer Strings zurückgibt, kann man nicht erkennen, um welche Art von Wert es sich handelt. Type<\/b> gibt einen Rückschluss darauf. Flags<\/b> wiederum ist ein Feld, das Hexadezimal-Strings ausgibt, welche weitere Informationen über die Art der Eigenschaft hervorbringen.<\/p>\n Es führt hier zu weit, dies zu erläutern und ich verweise auf den auskommentierten Block Property Type Flags<\/b> im Kopf des Moduls mdlPropStore<\/b>.<\/p>\n <\/p>\n HasCategory<\/b> schließlich gibt Auskunft darüber, ob es sich bei der Eigenschaft um ein Element einer bestimmten Kategorie handelt. Eigenschaften können nämlich kategorisiert werden. Die Hauptkategorie ist System<\/b>. Das sind alle in Windows verbauten Eigenschaften, wie beispielsweise System.FileOwner<\/b>. Hier kann es aber Unterkategorien geben. Bei Bildern etwa kommt die Kategorie System.Image<\/b> ins Spiel, die selbst keine Eigenschaft darstellt. System.Image.HorizontalSize<\/b> aber gibt die horizontale Ausdehnung der Bilddatei zurück. Alle Systemnamen, die mehr, als einen Punkt enthalten, sind Teil einer solchen Unterkategorie.<\/p>\n Eigenschaften hingegen, die von installierten Programmen ermittelt werden, haben nicht die Hauptkategorie System<\/b>, sondern eigene. Hier ist auf dem Rechner etwa die Corel Graphics Suite<\/b> installiert, die zusätzliche Property Handler<\/b> implementiert.<\/p>\n Die Hauptkategorie ist hier Corel<\/b> und eine Eigenschaft wäre Corel.File.CompressionRatio<\/b>, die zurückgibt, wie stark die Bilddatei komprimiert ist. Das allerdings funktioniert nur mit den speziellen Corel<\/b>-Dateitypen, wie .cdr<\/b>. Wie sich schließlich der Inhalt der Tabelle in der Datenblattansicht darstellt, zeigt Bild 5.<\/p>\n Bild 5: Ausschnitt der Datenblattansicht der Tabelle tblSysProperties mit allen für das System ermittelten Shell-Properties<\/span><\/b><\/p>\n Nur der Vollständigkeit halber ist in Listing 2 die Routine abgebildet, welche die Systemnamen enumeriert und in die Tabelle speichert. Es liegt deutlich außerhalb des Horizonts dieses Beitrags, ihre Funktionsweise zu erläutern, denn hier kommen recht exotische Interfaces<\/b> und Methoden zum Einsatz. Es sollte reichen, wenn Sie wissen, was<\/b> sie tut.<\/p>\n Listing 2: Diese Prozedur enumeriert alle auf dem System verfügbaren Systemnamen und speichert sie<\/span><\/b><\/p>\n Sie löscht zunächst optional (Parameter DeleteExisting<\/b>) alle Einträge in der Tabelle tblSysProperties<\/b> und öffnet dann ein Recordset rs<\/b> auf sie, um sie erneut mit Datensätzen zu füllen. Mit PSGetPropertySystem<\/b> wird folgend ein genereller Verweis auf das Property System<\/b> von Windows erhalten, was anhand einer speziellen Interface-GUID<\/b> (IID_IPropertySystem<\/b>) geschieht. EnumeratePropertyDescriptions<\/b> ist dann auch schon die Methode, welche die Liste der Eigenschaftennamen öffnet.<\/p>\n Die Zahl derer ermittelt GetCount<\/b> und eine Schleife arbeitet nun alle Einträge ab. Verschiedene Methoden berechnen den lokalen Anzeigenamen (Bezeichnung<\/b>), den Systemnamen (GetCanonicalName<\/b>), den Datentyp (GetDisplayType<\/b>) und die Flags (GetTypeFlags<\/b>). Die Ergebnisse werden jeweils den Feldern eines neuen Datensatzes (rs.AddNew<\/b>) zugewiesen. Damit ist die Tabelle mit allen registrierten Eigenschaftennamen gefüllt.<\/p>\n Der Prozedur StorePropertyKeys<\/b> können Sie optional einen Filterparameter What<\/b> übergeben, dessen Wert den Enumerationskonstanten PROPDESC_FILTER<\/b> der Bibliothek oleexp<\/b> entstammt. Der Standard ist 0<\/b>, was der Konstanten PDEF_ALL<\/b> entspricht und damit eigentlich alle Systemnamen ermitteln sollte. Ein anderer wäre etwa PDEF_VIEWABLE<\/b>, der nur jene Eigenschaften enumeriert, die als String angezeigt werden können. Oder PDEF_COLUMN<\/b>, was nur jene Eigenschaften zurückgibt, die auch der Explorer zur Auswahl anbietet. Seltsamerweise kommt es vor, dass in den über PDEF_ALL<\/b> erhaltenen Datensätzen manche fehlen, die etwa aus PDEF_VIEWABLE<\/b> kommen.<\/p>\n Deshalb ist es gegebenenfalls sinnvoll, die Prozedur mehrmals mit unterschiedlichen Konstanten aufzurufen und DeleteExisting<\/b> dabei auf False<\/b> zu setzen. Die Tabelle wird dann trotzdem keine Duplikate enthalten, weil das Feld Systemname<\/b> eindeutig indiziert ist, was übrigens der Grund dafür ist, weshalb die Schleife der Prozedur in ein On Error Resume Next<\/b> eingebunden ist. übrigens sind Sie mit der Konstanten PDEF_SYSTEM<\/b> mit Einschränkungen auf der sicheren Seite, weil damit nur die in Windows verbauten Eigenschaften zurückgegeben werden. Das allerdings gilt nur für eine bestimmte Windows-Version. Windows 10<\/b> etwa hält mehr Systemnamen vor, als Windows 7<\/b>.<\/p>\n Auf meinem System fanden sich schließlich 733 Eigenschaften ein, die auf Dateien und Verzeichnisse angewandt werden können. Welche Eigenschaftsnamen dabei bei welchen Dateitypen greifen, lässt sich leider nicht angeben. Der einfachste Weg ist daher, testweise alle möglichen Eigenschaften der besprochenen Prozedur SHGetPropertyString<\/b> zu übergeben. Kann die Shell<\/b> zu einer Datei mit dem Eigenschaftennamen nichts anfangen, so gibt die Funktion einen Leer-String zurück. Die Funktion ist absolut fehlertolerant. Sie könnten sich auch selbst Systemnamen ausdenken, die klaglos verarbeitet werden, aber eben ein leeres Ergebnis zeitigen.<\/p>\n Zusammengefasst können wir festhalten, dass Sie neben der Prozedur SHGetPropertyString <\/b>nur noch die gefüllte Tabelle tblSysProperties<\/b> benötigen, um in Ihrem Projekt Datei- und Ordnereigenschaften zu ermitteln. Den Verweis auf die Shell32<\/b>-Bibliothek sollten Sie dabei nicht vergessen. Eine Beispielanwendung zeigt nun das Formular frmFileProps<\/b> der Demo-Datenbank.<\/p>\n Starten Sie das Formular frmFileProps<\/b>, so erwartet Sie ein Textfeld oben, in welches Sie den Pfad einer Datei eingeben können. über den Button rechts daneben öffnen Sie einen Dateiauswahldialog, mit dem die Datei komfortabler ausgewählt werden kann. Unmittelbar danach füllt sich das Unterformular mit den Eigenschaftsdaten. Neben der lokalisierten Bezeichnung – unter einem spanischen Windows stünden hier eben die spanischen Pendants – steht in der zweiten Spalte der Systemname<\/b> der Eigenschaft und in der letzten deren Wert.<\/p>\n In Bild 6 wurde die Datei mscomctl.ocx<\/b> ausgewählt, die etwa das Treeview beherbergt. Die Shell konnte<\/b> hier 31 Eigenschaften auswerten. Interessant ist, dass zu diesen etwa auch die Dateiversion der PE<\/b>-Datei gehört (System.FileVersion<\/b>), welche allein schon Sie sonst nur über eine umfangreiche API<\/b>-Prozedur ermitteln könnten.<\/p>\n Bild 6: Die Liste der 31 ermittelten Eigenschaften der Datei mscomctl.ocx im Formular frmFileProps im Ausschnitt<\/span><\/b><\/p>\n Nicht uninteressant sind auch System.FileAttributes<\/b> und System.FileOwner<\/b>, die Aufschluss darüber geben, ob die Datei ohne administrative Rechte gelöscht, verschoben oder überschrieben werden kann.<\/p>\n Wenn Sie ein Verzeichnis selbst inspizieren möchten, so hilft der Dateiauswahldialog nicht weiter. Tragen Sie in diesem Fall den Pfad manuell ein und klicken Sie anschließend auf den Button mit dem Refresh<\/b>-Symbol, der auch sonst eine Neuabfrage der Eigenschaften bewirkt.<\/p>\n Die Checkbox Nur Basis-Infos<\/b> ist standardmäßig deaktiviert und führt dann zur Ausgabe aller Eigenschaften. Markieren Sie diese, so filtert das Formular jene Eigenschaften, die keine Unterkategorien aufweisen.<\/p>\n Das wird im nächsten Beispiel deutlicher. In Bild 7 wurde eine JPEG<\/b>-Bilddatei ausgewählt. Sind die Basis-Infos<\/b> aktiviert, so fehlen in der Liste jene Eigenschaften, die in der Abbildung farblich hervorgehoben wurden. Die gehören nämlich zu den Kategorien System.Image<\/b>, System.Media<\/b> und System.Photo<\/b> und zeigen erweiterte Eigenschaften zum Bild an. Wenn Sie etwa die Abmessungen eines Bilds erfahren möchten, so übergeben Sie der Prozedur SHGetPropertyString <\/b>einfach den Systemnamen System.Image.Dimensions<\/b>. Einfacher geht““s nun wirklich nicht mehr!<\/p>\n Bild 7: Die kompletten Eigenschaften der JPG-Datei weisen zusätzlich die hervorgehobenen Bereiche aus<\/span><\/b><\/p>\n Zu den erweiterten Eigenschaften gehören auch jene, die durch zusätzlich installierte Property Handler<\/b> ermittelt werden. Diese haben immer Unterkategorien. In Bild 8 wurde etwa eine PDF<\/b>-Datei geladen, wobei Sie hier nur einen Ausschnitt der Eigenschaften sehen. Das kostenlose Programm PDF-XChange-Viewer <\/b>der Firma Tracker Software<\/b> ist ein sehr empfehlenswerter Ersatz für den Adobe Reader<\/b>.<\/p>\n Bild 8: Durch installierte Programme können zusätzliche Dateieigenschaften ermittelt werden<\/span><\/b><\/p>\n Sein Property Handler<\/b> ermittelt nun Eigenschaften des Dokuments, wie Erstellanwendung (Producer<\/b>), Spezifikation (SpecVersion<\/b>) und Verschlüsselung (Encrypted<\/b>). Diese Eigenschaften ermittelt übrigens die Prozedur StorePropertyKeys<\/b>, wenn Sie im Parameter What<\/b> die Konstante PDEF_NONSYSTEM<\/b> übergeben. <\/p>\n Vielleicht fällt Ihnen beim Testen auf, dass die erste Zeile der Eigenschaften jeweils die Bezeichnung Verbs<\/b> aufweist. Das ist tatsächlich keine über die Funktion SHGetPropertyString <\/b>erhaltene Eigenschaft, sondern eine Liste von semikolonseparierten Datei- oder Ordneroperationen, die auf das Element ausgeführt werden können. Die wird mithilfe einer gesonderten Prozedur ermittelt, auf die wir noch zu sprechen kommen. Für diesen Eintrag gibt es außerdem eine Sonderfunktion: Doppelklicken Sie auf den Text Verbs<\/b>, so öffnet sich ein Meldungsfenster (siehe Bild 9), das die möglichen Operationen übersichtlicher ausgibt. Das ist genau die Liste, die Ihnen auch im Kontextmenü präsentiert wird, wenn Sie im Explorer auf eine Datei oder ein Verzeichnis rechtklicken.<\/p>\n Bild 9: Liste der möglichen Dateioperationen (Verbs) auf die JPEG-Datei<\/span><\/b><\/p>\n Im Prinzip funktioniert sie so: Alle Systemnamen der Tabelle tblSysProperties<\/b> werden nacheinander der Funktion SHGetPropertyString<\/b> übergeben. Nur jene, die keinen Leer-String zurückgeben, kommen dann ins Ergebnis. Die Werte werden in einer neuen Tabelle tblFileProps<\/b> gespeichert, die die Datenherkunft für das Unterformular sfrmFileProps<\/b> bildet. Ihren Entwurf, der dem der Tabelle tblSysProperties<\/b> ähnelt, zeigt Bild 10. Den Wert einer Eigenschaft<\/b> speichert allerdings hier das gleichnamige Feld, welches sicherheitshalber im Memo<\/b>-Format daherkommt, weil etwa die Liste der Verbs<\/b> den Zeichenumfang eines Textfelds sprengen könnte.<\/p>\n Bild 10: Die Entwurfsansicht der Tabelle tblFileProps für die Anzeige im Unterformular sfrmFileProps<\/span><\/b><\/p>\n Den Formularentwurf finden Sie in Bild 11. Das Unterformular sfrmFileProps<\/b> ist auf den Modus Datenblatt<\/b> eingestellt und hat als Datenherkunft die einzige Abfrage qry_FileProps<\/b> der Beispieldatenbank. Sie gibt lediglich den Inhalt der Tabelle tblFileProps<\/b>, sortiert nach dem Feld Bezeichnung<\/b>, zurück.<\/p>\n Bild 11: Die Entwurfsansicht des Formulars frmFileProps zeigt das Unterformular sfrmFileProps zur Auflistung der Dateieigenschaften<\/span><\/b><\/p>\n Der wesentliche VBA-Code wird als Reaktion auf die Ereignisse Click<\/b> des Dateiauswahl-Button oder des Refresh-Button ausgeführt. Nur beim Laden des Formulars laufen zusätzlich einige Initialisierungsaufgaben ab. Die Ereignisprozedur Form_Load<\/b> stellt Listing 3 dar. Hier wird das globale Recordset rsSys<\/b> auf die Herkunft tblSysProperties<\/b> eingestellt, weil seine Daten immer wieder benötigt werden. Außerdem wird die ebenfalls formularglobale Objektvariable oShell<\/b> auf eine neue Instanz der Klasse Shell32.Shell<\/b> gesetzt und im String sDir<\/b> der Pfad der Datenbankdatei festgelegt, den wir als Startverzeichnis des Dateiauswahldialogs verwenden werden. Die dafür verantwortliche Prozedur geben wir hier nicht wieder – sie verbirgt sich hinter der Ereignisprozedur cmdOF_Click<\/b>.<\/p>\n Listing 3: Initialisierungsvorgänge im Formularereignis Beim Laden<\/span><\/b><\/p>\n Sowohl die Auswahl einer Datei, wie auch der Klick auf den Refresh-Button, rufen die eigentliche Funktion, die Prozedur EnumProps<\/b>, in Listing 4 aus. Im Wesentlichen durchläuft hier eine Schleife alle Datensätze der Tabelle tblSysProperties<\/b> und entnimmt ihr jeweils den Eigenschaftennamen, um ihn in der Variablen sSys<\/b> zwischenzuspeichern. Ob nur Basis-Infos erhalten werden sollen, entscheidet die Boole-Variable bDoIt<\/b> anhand des Werts der Checkbox chkBaseInfo<\/b> (in bBase<\/b>) und der Berechnung, ob der Systemname mehr, als einen Punkt, enthält. Das ermittelt die Split<\/b>-Funktion im Verein mit der UBound<\/b>-Funktion. Der zusammengesetzte Boole-Ausdruck mag etwas kryptisch aussehen, reduziert jedoch den Code und damit das Listing hier.<\/p>\n Listing 4: Diese Prozedur enumeriert die Dateieigenschaften<\/span><\/b><\/p>\n Den Rückgabewert von SHGetPropertyString<\/b> (Modul mdlPropsShell<\/b>) speichert sProp<\/b>. Ist die Länge dieses Strings großer, als 0<\/b>, so kommt es nur Anlage eines neuen Datensatzes im auf der Tabelle tblFileProps<\/b> basierenden Recordset rs<\/b>. Sind alle Eigenschaften enumeriert, so schließt das Recordset und das Unterformular wird mittels Requery<\/b> neu gefüllt.<\/p>\n Im Listing fehlt allerdings noch die Anlage des einen Datensatzes für die Verbs<\/b>:<\/p>\n Die Liste der möglichen Datei- oder Verzeichnisoperationen ist in die Funktion SHGetFileVerbs<\/b> (ebenfalls Modul mdlPropsShell<\/b>) ausgelagert, die Listing 5 zeigt.<\/p>\n![\"Liste](\"..\/fileadmin\/_temp_\/2018_02\/ExlorerDlg.png\")
<\/p>\n![\"Informationen](\"..\/fileadmin\/_temp_\/2018_02\/ExplorerProps.png\")
<\/p>\nDas Windows Property System<\/h2>\n
Datenbank für Dateieigenschaften<\/h2>\n
Dim <\/span>oSH As <\/span>Shell32.Shell\r\nFunction <\/span>SHGetPropertyString(sFile As String<\/span>, sProp As String<\/span>) As String<\/span>\r\n Dim <\/span>sFld As String<\/span>, sFil As String<\/span>\r\n Dim <\/span>oFld As <\/span>Shell32.Folder3\r\n Dim <\/span>oItm As <\/span>Shell32.ShellFolderItem\r\n Dim <\/span>vRet As Variant<\/span>\r\n \r\n If <\/span>oSH Is Nothing Then<\/span> Set<\/span> oSH = New<\/span> Shell32.Shell\r\n \r\n sFld = Left<\/span>(sFile, InStrRev<\/span>(sFile, \"\\\") - 1)\r\n sFil = Mid<\/span>(sFile, InStrRev<\/span>(sFile, \"\\\") + 1)\r\n Set<\/span> oFld = oSH.NameSpace(CStr(sFld))\r\n If <\/span>Len<\/span>(sFil) = 0 Then<\/span>\r\n Set<\/span> oItm = oFld.Self\r\n Else<\/span>\r\n Set<\/span> oItm = oFld.Items.Item(CStr(sFil))\r\n End If<\/span>\r\n vRet = oItm.ExtendedProperty(sProp)\r\n If <\/span>IsArray(vRet) Then<\/span>\r\n SHGetPropertyString = Join(vRet, \";\")\r\n Else<\/span>\r\n SHGetPropertyString = vRet\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\n SHGetPropertyString(\"d:\\mp3s\\fullalbum.mp3\", \"System.Size\")\r\n-> \"62356466\"<\/pre>\n
-> \"02.11.2017 16:23:48\"<\/pre>\n
-> \"MeinComputername\\Herbert\"<\/pre>\n
Set<\/span> oSH = CreateObject(\"Shell.Application\")<\/pre>\nsFld -> \"d:\\mp3s\"\r\nsFil -> \"fullalbum.mp3\"<\/pre>\n
System Property Names<\/h2>\n
On Error Resume Next<\/span>\r\nReferences.AddFromFile CurrentProject.Path & \"\\oleexp.tlb\"<\/pre>\n![\"In](\"..\/fileadmin\/_temp_\/2018_02\/tblSysProperties_DS.png\")
<\/p>\n![\"Ausschnitt](\"..\/fileadmin\/_temp_\/2018_02\/tblSysProperties_RT.png\")
<\/p>\nPublic Sub <\/span>StorePropertyKeys(Optional<\/span> What As <\/span>oleexp.PROPDESC_ENUMFILTER, _\r\n Optional<\/span> DeleteExisting As Boolean<\/span> = True<\/span>)\r\n Dim <\/span>i As Long<\/span>\r\n Dim <\/span>IPSys As <\/span>IPropertySystem\r\n Dim <\/span>IPropDesc As <\/span>IPropertyDescription\r\n Dim <\/span>IPList As <\/span>IPropertyDescriptionList\r\n Dim <\/span>nProp As Long<\/span>, lpProp As Long<\/span>, lType As Long<\/span>, lFlag As Long<\/span>\r\n Dim <\/span>rs As <\/span>DAO.Recordset\r\n Dim <\/span>cnt As Long<\/span>\r\n If <\/span>DeleteExisting Then<\/span> CurrentDb.Execute \"DELETE FROM tblSysProperties\"\r\n Set<\/span> rs = CurrentDb.OpenRecordset(\"SELECT * FROM tblSysProperties\", dbOpenDynaset)\r\n PSGetPropertySystem String2UID(IID_IPropertySystem), IPSys\r\n On Error Resume Next<\/span>\r\n IPSys.EnumeratePropertyDescriptions What, String2UID(IID_IPropertyDescriptionList), IPList\r\n IPList.GetCount nProp\r\n For i = 0 To (nProp - 1)\r\n IPList.GetAt i, String2UID(IID_IPropertyDescription), IPropDesc\r\n IPropDesc.GetDisplayName lpProp\r\n If <\/span>lpProp <> 0 Then<\/span>\r\n rs.AddNew<\/span>\r\n rs!Bezeichnung = SysAllocString(lpProp) & \"\"\r\n CoTaskMemFree lpProp\r\n IPropDesc.GetCanonicalName lpProp\r\n IPropDesc.GetDisplayType lType\r\n IPropDesc.GetTypeFlags PDTF_MASK_ALL, lFlag\r\n rs!Systemname = SysAllocString(lpProp)\r\n CoTaskMemFree lpProp\r\n rs!Type = Choose(1 + lType, \"String\", \"Number\", \"Boolean\", \"DateTime\", \"Enum\")\r\n rs!Flags = Hex(lFlag)\r\n rs!HasCategory = UBound<\/span>(Split<\/span>(rs!Systemname.Value, \".\")) > 1\r\n Err.Clear\r\n rs.Update\r\n If <\/span>Err.Number <> 0 Then<\/span> rs.CancelUpdate Else cnt = cnt + 1\r\n End If<\/span>\r\n Next<\/span> i\r\n rs.Close\r\nEnd Sub<\/span>\r\nPrivate Function <\/span>String2UID(sGUID As String<\/span>) As <\/span>oleexp.UUID\r\n oleexp.CLSIDFromString sGUID, String2UID\r\nEnd Function<\/span><\/pre>\nPraxisanwendung<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2018_02\/frmFileProps_1.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2018_02\/frmFileProps_Ext.png\")
<\/p>\n![\"Durch](\"..\/fileadmin\/_temp_\/2018_02\/AdditionalProps.png\")
<\/p>\n![\"Liste](\"..\/fileadmin\/_temp_\/2018_02\/Popup_Verbs.png\")
<\/p>\nAufbau der Anwendung<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2018_02\/tblFileProps_DS.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2018_02\/frmFileProps_DS.png\")
<\/p>\nPrivate <\/span>rsSys As <\/span>DAO.Recordset\r\nPrivate <\/span>oShell As <\/span>Shell32.Shell\r\nPrivate <\/span>sDir As String<\/span> \r\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> rsSys = CurrentDb.OpenRecordset _\r\n (\"SELECT * FROM tblSysProperties\", dbOpenSnapshot)\r\n Set<\/span> oShell = New<\/span> Shell32.Shell\r\n sDir = CurrentProject.Path\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>EnumProps(sFile As String<\/span>)\r\n Dim <\/span>rs As <\/span>DAO.Recordset\r\n Dim <\/span>sSys As String<\/span>, sProp As String<\/span>\r\n Dim <\/span>bBase As Boolean<\/span>, bDoIt As Boolean<\/span>\r\n Dim <\/span>arrProp() As String<\/span>\r\n bBase = Me!chkBaseInfo.Value\r\n CurrentDb.Execute \"DELETE FROM tblFileProps\"\r\n Set<\/span> rs = CurrentDb.OpenRecordset (\"SELECT * FROM tblFileProps\")\r\n rsSys.MoveFirst\r\n Set<\/span> oItm = Nothing\r\n Do While<\/span> Not<\/span> rsSys.EOF\r\n sSys = rsSys!Systemname\r\n bDoIt = ((UBound<\/span>(Split<\/span>(sSys, \".\")) = 1) And bBase) Or (Not<\/span> bBase)\r\n If <\/span>bDoIt Then<\/span>\r\n sProp = SHGetPropertyString(sFile, sSys)\r\n If <\/span>Len<\/span>(sProp) > 0 Then<\/span>\r\n rs.AddNew<\/span>\r\n rs!Bezeichnung = rsSys!Bezeichnung\r\n rs!Eigenschaft = sProp\r\n rs!Systemname = rsSys!Systemname\r\n rs.Update\r\n End If<\/span>\r\n End If<\/span>\r\n rsSys.MoveNext<\/span>\r\n Loop<\/span>\r\n'''' ... (Plus Verbs) ...\r\n rs.Close\r\n Me!sfrmProps.Requery\r\nEnd Sub<\/span><\/pre>\n rs.AddNew<\/span>\r\n rs!Bezeichnung = \"Verbs\"\r\n rs!Eigenschaft = SHGetFileVerbs(sFile)\r\n rs.Update<\/pre>\nFunction <\/span>SHGetFileVerbs(sFile As String<\/span>) As String<\/span>\r\n Dim <\/span>sFld As String<\/span>, sFil As String<\/span>\r\n Dim <\/span>oFld As <\/span>Shell32.Folder3\r\n Dim <\/span>oItm As <\/span>Shell32.ShellFolderItem\r\n Dim <\/span>vrb As <\/span>FolderItemVerb\r\n Dim <\/span>sVerbs As String<\/span>\r\n If <\/span>oSH Is Nothing Then<\/span> Set<\/span> oSH = New<\/span> Shell32.Shell\r\n sFld = Left<\/span>(sFile, InStrRev<\/span>(sFile, \"\\\") - 1)\r\n sFil = Mid<\/span>(sFile, InStrRev<\/span>(sFile, \"\\\") + 1)\r\n Set<\/span> oFld = oSH.NameSpace(CStr(sFld))\r\n Set<\/span> oItm = oFld.Items.Item(CStr(sFil))\r\n If <\/span>oItm Is Nothing Then<\/span> Exit Function<\/span>\r\n For Each vrb In oItm.Verbs\r\n If <\/span>Len<\/span>(vrb.Name) > 0 Then<\/span>\r\n sVerbs = sVerbs \r\n & Replace<\/span>(vrb.Name, \"&\", \"\") & \";\"\r\n End If<\/span>\r\n