<\/p>\n
Hin und wieder kommt es vor, dass Sie aus Access heraus den Windows Explorer öffnen und dabei gleich ein Verzeichnis Ihrer Wahl ansteuern möchten. Gründe dafür gibt es viele. Haben Sie etwa eine Textdatei exportiert, so macht es sich gut, dem Anwender anschließend gleich den passenden Ordner zu präsentieren und dort die Datei zu markieren. über einige Zeilen VBA-Code rund um ein Shell-Objekt ist das schnell realisiert.<\/b><\/p>\nExplorer aufrufen<\/h2>\n
Der Explorer<\/b> ist eine Anwendung, die die Verwaltung der Windows Shell<\/b> oder zumindest Teile von ihr, erlaubt. Wir erwähnen diesen Zusammenhang nur, weil später noch ausführlicher auf Shell<\/b>-Objekte unter VBA eingegangen wird.<\/p>\n
Um ausführbare Dateien zu starten, können Sie die VBA-Anweisung Shell<\/b> verwenden. Sie übergeben ihr als Parameter den Pfad zur ausführbaren Datei und optional noch den Fenstermodus, in dem sie gestartet werden soll:<\/p>\n Diese Zeile öffnet den Windows Explorer in einem normalen Fenster. Sie können dieses jedoch auch gleich maximieren:<\/p>\n Den Pfad zur explorer.exe <\/b>müssen Sie nicht voll ausschreiben oder kennen, da sie sich im Suchpfad von Windows befindet. War““s das schon Nein, natürlich nicht! Denn erstens gibt es noch diverse Kommandozeilenoptionen für den Explorer, die zu erläutern wären, und zweitens stellen wir noch eine Alternative zur Shell<\/b>-Anweisung vor.<\/p>\n Vielleicht ist Ihnen diese Funktion schon einmal untergekommen. Es gibt zwar eine Windows-API<\/b>-Funktion gleichen Namens, doch wir verwenden sie im Zusammenhang mit der Shell<\/b>-Bibliothek, wo sie ebenfalls vorkommt und auch identische Funktionalität aufweist.<\/p>\n Dazu benötigen wir einen Verweis auf diese Bibliothek. öffnen Sie im VBA-Editor unter Extras|Verweise<\/b> den entsprechenden Dialog und aktivieren Sie den Eintrag Microsoft Shell Controls And Automation<\/b>. Diese Bibliothek ist grundsätzlich unter jeder Version von Windows vorhanden und verweist auf die shell32.dll<\/b>. Nun können Sie ein Shell<\/b>-Objekt anlegen:<\/p>\n Wenn Sie im VBA-Objektkatalog oben die Bibliothek Shell32<\/b> auswählen und links zur Shell<\/b>-Klasse navigieren, so finden Sie rechts deren zahlreiche Methoden, und deren Namen sagen bereits einiges über das Thema der Klasse aus. <\/p>\n Uns interessiert im Moment nur die Methode ShellExecute<\/b>, die ähnlich arbeitet, wie die Shell<\/b>-Anweisung von VBA, jedoch mit deutlich mehr Parametern ausgestattet ist, die die Funktionalität erweitern. Mit dieser Zeile öffnen Sie den Explorer, nachdem das Shell<\/b>-Objekt angelegt wurde:<\/p>\n Mehrere Parameter der Methode sind optional, was durch die Kommas deutlich wird. Zunächst erwartet die Funktion den Pfad der ausführbaren Datei, wobei dieser auch hier nicht vollständig angegeben werden muss.<\/p>\n Der zweite Parameter gibt die Kommandozeilenoptionen<\/b> an, die der Anwendung mitgegeben werden sollen. Soll der Explorer das Verzeichnis c:\\windows<\/b> anzeigen, so ist hier der richtige Ort für die Pfadangabe:<\/p>\n Damit weicht die Syntax dieser Funktion von der Shell<\/b>-Anweisung ab, bei der beide Angaben in einem String zu kombinieren wären:<\/p>\n Das macht die Sache etwas übersichtlicher. Der dritte optionale Parameter gibt den Ausführungspfad an. Wie bei Dateiverknüpfungen können Sie hier festlegen, welches Standardverzeichnis dem startenden Prozess zugeeignet wird. In der Regel kann dieser Parameter ignoriert werden.<\/p>\n Das Interessante an der ShellExecute<\/b>-Funktion ist nun der vierte Parameter, der das sogenannte Aktions-Verb<\/b> erwartet. Das sind Strings, die die auf den Prozess auszuführende Aktion angeben. Der Standard ist open <\/b>für normales Starten der Anwendung. Lassen Sie den Parameter aus, so setzt Windows funktional automatisch open <\/b>ein. Es gibt aber natürlich noch weitere Verben, auf die später noch die Sprache kommt.<\/p>\n Der letzte Parameter ist identisch mit dem der Shell<\/b>-Anweisung und gibt den Fenstermodus an. Die 1<\/b> im Beispiel entspricht dem vbNormalFocus<\/b>. Sie können hier also die gleichen Konstanten angeben, wie bei der Shell<\/b>-Anweisung.<\/p>\n Damit Sie nicht in jeder Routine, die das Shell<\/b>-Objekt benötigt, dieses per New<\/b> neu anlegen müssen, greifen Sie zu einer Hilfsfunktion, wie in Listing 1. Dort ist in einem Modul die Variable m_Shell<\/b> als globales Shell<\/b>-Objekt deklariert.<\/p>\n Listing 1: Funktion zum Zurückgeben des Shell-Objekts<\/span><\/b><\/p>\n Die Funktion oShell<\/b> gibt dieses Objekt schlicht zurück, überprüft davor jedoch mit einem Test auf Nothing<\/b>, ob es überhaupt gefüllt ist. Falls nicht, so wird der Variablen ein neues Shell<\/b>-Objekt verabreicht. oShell<\/b> können Sie nun an jeder beliebigen Stelle im VBA-Projekt verwenden, wenn Sie ein Shell<\/b>-Objekt benötigen.<\/p>\n Anhand der folgenden Prozeduren erläutern wir, wie sich der aufgerufene Explorer über Kommandozeilenoptionen steuern lässt (s. Listing 2).<\/p>\n Listing 2: Verschiedene Routinen mit Optionen zum Starten des Explorers<\/span><\/b><\/p>\n Die erste Option lernten Sie bereits kennen. Sie öffnet den Explorer mit vorgegebenem Pfad (Prozedur RunExplorerFolder<\/b>). In RunExplorerList<\/b> ist dem Pfad c:\\windows<\/b> noch ein \/e,<\/b> vorangestellt.<\/p>\n Das soll nach Aussage von Microsoft den Explorer im Modus mit Verzeichnisbaum links und Dateien rechts öffnen. Ohne dieses \/e <\/b>würde sich nur der Ordner allein öffnen. Diese Aussage ist für neuere Windows-Versionen nicht mehr gültig. Die geteilte Ansicht tritt in beiden Fällen ein.<\/p>\n Wie daraus aber zu erkennen ist, werden mehrere Optionen durch Kommas getrennt aneinander gefügt. Gibt man als weitere Option \/root <\/b>an, so wird der folgende Pfad als Startverzeichnis des Explorers angewählt (Prozedur RunExplorerRoot<\/b>). Alle anderen Elemente sind ausgeblendet. Sie können in diesem Explorer also nicht auf darüber liegende Verzeichnisse oder Laufwerke wechseln.<\/p>\n Die entsprechenden Schaltflächen fehlen auch im Menüband. <\/p>\n Schließlich lässt sich über die Option \/Select <\/b>auch direkt ein Verzeichnis oder eine Datei im sich öffnenden Explorer markieren.<\/p>\n Dazu fügen Sie deren Pfad unmittelbar hinter die Anweisung an (Prozeduren RunExplorerSelectFile<\/b> und RunExplorerSelectFolder<\/b>).<\/p>\n Leider lässt sich diese Option nicht mit \/root<\/b> kombinieren.<\/p>\n Das bedeutet: Wenn Sie Verzeichnisse oder Dateien vormarkieren, so bleibt links leider der ganze Baum bestehen.<\/p>\n Der Versuch, beide Optionen dennoch zu kombinieren, führt ohne Fehlermeldung schlicht zur Anzeige des Desktops im Explorer.<\/p>\n Möchten Sie den Explorer mit der Auswahl Computer<\/b> starten, so greifen Sie wie in Prozedur RunExplorerComputer<\/b> aus Listing 3 zu einem Trick: übergeben Sie einfach nur ein Komma als Options-String. <\/p>\n <\/p>\n Listing 3: Prozeduren zum erweiterten Starten des Explorers<\/span><\/b><\/p>\n Die Routine OpenFileExplorer<\/b> ist allgemeiner gehalten. Als Parameter übergeben Sie ihr in sFile<\/b> den Pfad einer Datei oder eines Orders. Dieser wird dann im Explorer geöffnet und markiert, indem die \/Select<\/b>-Option mit der String-Variablen verkettet wird.<\/p>\n Nun finden Sie im Explorer ja nicht nur Elemente des Dateisystems, wie das noch bis Windows 98<\/b> der Fall war, sondern auch solche, wie Systemsteuerung<\/b> oder Netzwerke<\/b>. Diese Elemente besitzen keinen Verzeichnispfad.<\/p>\n Und dennoch kann man sie ansteuern: Dazu bedarf es anstelle des Pfads einer speziellen GUID<\/b>, die das Element eindeutig identifiziert. Die Routine RunExplorerSys<\/b> etwa öffnet die Systemsteuerung, weil diese grundsätzlich die angegebene GUID<\/b> besitzt.<\/p>\n Die Schreibweise ist dabei immer gleich: vor die eigentliche GUID<\/b> kommen zwei Doppelpunkte. Diese Shell<\/b>-Objekte sind unter dem Namen SpecialFolders<\/b> bekannt, wobei jene mit einer GUID<\/b> eigentlich SpecialSpecialFolders<\/b> heißen müssten, wie wir noch sehen werden.<\/p>\n Da diese Elemente wiederum im Prinzip Ordner darstellen können, ist auch der Bezug auf deren Unterelemente möglich. Die Systemsteuerung enthält etwa die Liste der Drucker.<\/p>\n Auf sie beziehen Sie sich, indem Sie an die GUID<\/b> eine weitere, wie einen Unterordner durch den BackSlash getrennt, anfügen. So kommen Sie in RunExplorerPrinters<\/b> direkt in die Verzeichnisliste der Drucker des Systems.<\/p>\n Sie fragen sich vielleicht, wo die GUIDs herkommen Das ist leider nicht so einfach zu beantworten. Zwar gibt es generell gültige Shell<\/b>-Elemente mit vorgegebener GUID, wie etwa bei der Systemsteuerung, doch durch installierbare Shell-Erweiterungen sieht die Sache auf jedem System anders aus. Zum Glück können Sie über die Shell32<\/b>-Bibliothek diese GUIDs<\/b> für ihr System selbst ermitteln…<\/p>\n Bisher verwendeten wir nur die eine Methode ShellExecute<\/b> des Shell-Objekts. Eine mächtige Funktion ist daneben NameSpace<\/b>, die uns zu neuen Klassen der Bibliothek führt.<\/p>\n NameSpace<\/b> übergibt man einen Parameter des Typs Variant<\/b>. Dabei kann es sich um einen String oder eine Zahl handeln. Zurück bekommt man dann ein Objekt der Klasse Folder<\/b>.<\/p>\n Die Methode ist also dafür gemacht, um virtuelle Ordner-Objekte anhand von Parametern zurückzugeben. Ein einfaches Beispiel:<\/p>\n Hier bekommen wir ein virtuelles Objekt mit Bezug auf den physischen Ordner c:<\/b>. Virtuell deshalb, weil ein Folder<\/b>-Objekt nicht nur ein Element des Dateisystems darstellen kann, sondern abstrakt zum Beispiel auch die Drucker der Systemsteuerung. <\/p>\n Das Folder<\/b>-Objekt hat verschiedene Eigenschaften, von der die Title<\/b>-Eigenschaft vielleicht die wichtigste ist:<\/p>\n Leider gibt Title<\/b> die Bezeichnung des Folders zurück, nicht den Pfadnamen allein. Deshalb ist ein kleiner Umstand nötig. Die Eigenschaft Self<\/b> des Folder<\/b>-Objekts stellt ein neues Objekt der Klasse FolderItem<\/b> dar, welche wiederum die Eigenschaft Path<\/b> kennt. Den Pfad eines Folders ermittelt man demnach so:<\/p>\n Statt des Strings zur Pfadangabe kann – Sie werden es sich denken können – auch eine SpecialFolder-GUID<\/b> als Parameter übergeben werden:<\/p>\n Und schließlich wurde erwähnt, dass auch eine Zahl als Parameter für NameSpace<\/b> dienen kann. Testen Sie das:<\/p>\n Die 0<\/b> entspricht also dem Desktop-Ordner Ihres Windows-Kontos. Die Zahlen, die hier übergeben werden können, sind im Bereich von 0 bis 255. Es handelt sich um IDs<\/b> von Windows-Spezialverzeichnissen, eben der Special Folders<\/b>. Dies gibt uns die Möglichkeit, alle Spezialordner von Windows in einer Schleife zu enumerieren:<\/p>\n Heraus kommt dabei ungefähr das:<\/p>\n Neben der Bezeichnung der virtuellen Ordner, die teilweise lokalisiert und teilweise Englisch ist, erhalten Sie also auch den Pfad jedes Elements, der entweder als Dateisystempfad oder als GUID<\/b> daher kommt. Auf diese Weise ermitteln Sie selbst alle Pfade von Spezialordnern von Windows, und damit kehren wir zurück zum Aufruf des Explorers.<\/p>\n Um den Explorer mit dem Desktop zu öffnen, können Sie einfach diese Zeile aufrufen:<\/p>\n Das bedeutet, dass Sie sich um die Ermittlung des Pfads oder der GUIDs<\/b> von Spezialordnern nicht weiter kümmern müssen, um diese im Explorer zu öffnen. Die Zahl zur Folder-ID <\/b>reicht aus. Zu erwähnen wäre noch, dass es nicht zu allen Zahlen im Bereich von 0 bis 255 eine Spezialordnerentsprechung gibt.<\/p>\n Der Aufruf von Namespace<\/b> mit einer solchen ungültigen Zahl führt in der Schleife zu einem Fehler. Deshalb muss ihr ein On Error Resume Next <\/b>vorangestellt werden, um diese Fehler zu ignorieren.<\/p>\n Damit die ganze Geschichte noch anschaulicher wird, enthält die Beispieldatenbank im Modul mdlShell<\/b> einige Prozeduren, mit denen die Spezialordner in Tabellen geschrieben werden können. Wegen ihres Umfangs lassen wir ihre Darstellung in Listings hier ausnahmsweise außen vor.<\/p>\n Rufen Sie etwa die Prozedur StoreSpecialFolders<\/b> auf, so schreibt diese die gewünschten Angaben in die Tabelle tblShellFolders<\/b>. Das Ergebnis sieht aus wie in Bild 1. In der Spalte SFID<\/b> stehen die Nummern der Ordner, in Name<\/b> deren Bezeichnung und unter Path<\/b> der Pfad. Unter jedem Windows-Konto kommen hier unterschiedliche Werte heraus!<\/p>\n Bild 1: Die Windows-Spezialordner sind in der Tabelle tblShellFolders abgespeichert<\/span><\/b><\/p>\n Um die Angelegenheit noch weiter aufzubohren, existieren in der Datenbank drei weitere Tabellen, die sich um die speziellen GUID-Ordner ranken. Das Datenmodell finden Sie in Bild 2.<\/p>\n Bild 2: Die drei Tabellen der Beispieldatenbank rund um Windows-Spezialordner<\/span><\/b><\/p>\n Die Tabelle tblSpecialFolders<\/b> gleicht in ihrem Aufbau der tblShellFolders<\/b>, nur dass hier ausschließlich die virtuellen GUID-Ordner abgespeichert werden (s. Bild 3).<\/p>\n Bild 3: Alle ermittelten GUID-Spezialordner finden sich nach Aufruf von NameSpacesToTable in der Tabelle tblSpecialFolders<\/span><\/b><\/p>\n Sie füllen sie über die Prozedur NameSpacesToTable<\/b>.<\/p>\n Da ein Ordner sowohl Elemente als auch Unterordner enthalten kann, enumeriert die Routine NamespaceFoldersToTable<\/b> auch diese, um sie in der verknüpften Tabelle tblSpecialSubFolders<\/b> zu speichern (s. Ausschnitt in Bild 4).<\/p>\n Bild 4: Die Unterordner der virtuellen GUID-Ordner speichert eine Routine in der Tabelle tblSpecialSubFolders<\/span><\/b><\/p>\n Hier sind etwa die einzelnen Elemente der Systemsteuerung zu finden, wobei es sich dabei nur teilweise um Unterordner handelt. Die Energieoptionen<\/b> etwa sind kein Ordner, sondern ein Ordnerelement (FolderItem<\/b>).<\/p>\n Hingegen handelt es sich bei der Verwaltung<\/b> tatsächlich um einen virtuellen Ordner, der seinerseits Elemente wie die Ereignisanzeige<\/b> oder den ODBC-Datenquellenadministrator<\/b> enthält.<\/p>\n Damit auch diese Elemente in die übersicht gelangen, enumeriert die Routine NamespaceFolderItems<\/b> alle Elemente aller Unterordner und speichert diese in der Tabelle tblSpecialItems<\/b> (s. Bild 5). Sie sehen, dass damit etwa auch alle installierten Drucker aufgeführt werden. Zu Laufwerken werden sowohl deren Ordner, wie auch etwaige Dateien aufgeführt. Bei unserem Test füllte sich die Tabelle deshalb mit über 2.000 Datensätzen.<\/p>\n Bild 5: Die eigentlichen Elemente der Spezialordner in der Tabelle tblSpecialItems<\/span><\/b><\/p>\n Nachdem alle Routinen durchlaufen wurden, kann die Tabelle tblSpecialFolders<\/b> als Datenblatt geöffnet werden und zeigt dabei die Detailtabellen, hierarchisch gemäß den Tabellenbeziehungen, als Unterdatenblätter an, wie Bild 6 demonstriert. Die Systemsteuerung<\/b> enthält die Auflistung Verwaltung<\/b> und diese selbst 16 Elemente.<\/p>\n Bild 6: Hierarchische Anzeige in der Tabelle tblSpecialFolders<\/span><\/b><\/p>\n Der Aufruf des Explorers über das Shell-Objekt<\/b>, statt über die Shell-Anweisung<\/b> von VBA, hatte noch einen weiteren Vorteil. Das open-Verb<\/b> führt zu normalem öffnen der Anwendung. Doch hier lassen sich, je nach Anwendung, auch andere Verben<\/b> einsetzen. Ein recht spezieller Fall ist das Verb<\/b> runas<\/b>.<\/p>\n Das sagt Windows, dass die Anwendung im Adminstratorkontext gestartet werden soll, nicht im Benutzerkontext. Führt man dies aus, so meldet sich Windows mit der üblichen UAC<\/b>-Sicherheitsabfrage, die das Starten des Prozesses erst einmal bestätigen lässt.<\/p>\n Bei Bejahung hat man mit dieser Zeile ein Explorer-Fenster geöffnet, das administrative Vorgänge zulässt:<\/p>\n Selbstverständlich könnten Sie auch hier weitere Angaben zu den öffnungsoptionen und Pfaden machen.<\/p>\n Nebenbei lässt sich über dieses Verb<\/b> auch eine neue Instanz von Access selbst starten, die über administrative Rechte verfügt:<\/p>\n Diese Instanz und ihre VBA-Routinen könnten dann – einen schönen Gruß an die Hacker unter Ihnen! – etwa auch in geschützte Systemverzeichnisse schreiben.<\/p>\n Mit dem Aufruf des Explorers haben die folgenden Ausführungen nichts mehr zu tun, wir möchten Ihnen die Hintergründe zu Shell-Verben<\/b> aber nicht vorenthalten. Listing 4 zeigt eine Prozedur, die alle möglichen Verben eines Druckers ausgibt.<\/p>\n Listing 4: Ausgeben aller Verben eines bestimmten Druckers<\/span><\/b><\/p>\n Zunächst wird das Folder<\/b>-Objekt fld<\/b> auf den virtuellen Drucker-Ordner von Windows gesetzt, der durch die Special Folders-ID<\/b> 4<\/b> bestimmt ist. Dann nimmt die Prozedur den ersten Drucker, das erste Element in Gestalt des FolderItems<\/b> 1<\/b>, und enumeriert in einer For-Each<\/b>-Schleife alle Verben<\/b> (Objektvariable vrb<\/b>) dieses Shell<\/b>-Objekts, um sie im VBA-Direktfenster auszugeben. Jedes FolderItem<\/b>-Objekt hat diese Auflistungseigenschaft Verbs<\/b>.<\/p>\n Als Ergebnis erhalten Sie etwa diese Liste:<\/p>\n Sie könnten auch etwa das Folder<\/b>-Objekt auf einen Dateipfad setzen und bekämen dann eine ganz andere Liste zu Gesicht.<\/p>\n Bedauerlicherweise handelt es sich hier um lokalisierte Verben, die sich nicht direkt als Verb für ShellExecute<\/b> einsetzen lassen. Es gibt auch keine übersetzungsfunktion. Eine gültige Liste der Verben für ShellExecute<\/b> ist jedenfalls diese:<\/p>\n Diese Verben funktionieren nur bei bestimmten Shell<\/b>-Objekten. Für die explorer.exe<\/b> etwa machen das Ausschneiden oder Drucken keinen Sinn.<\/p>\n Für DVD-Laufwerksobjekte hingegen gäbe es auch noch das Verb eject<\/b>, welches die Laufwerksschublade öffnet.<\/p>\n Unterschlagen haben wir bisher auch, dass sich ShellExecute<\/b> im Gegensatz zu VBA-Shell<\/b> nicht nur auf ausführbare Dateien beschränkt, sondern mit allen Dateitypen funktioniert. <\/p>\n übergeben Sie als Argument etwa eine Textdatei, so öffnet sich diese mit der verknüpften Anwendung – vermutlich Notepad<\/b>. Listing 5 zeigt, wie auf ein FolderItem<\/b> zur Datei sample.txt<\/b> zwei unterschiedliche Verben angewandt werden.<\/p>\nShell \"Explorer.exe\", vbNormalFocus<\/pre>\n
Shell \"Explorer.exe\", vbMaximizedFocus<\/pre>\n
ShellExecute<\/h2>\n
Dim <\/span>oShell As <\/span>Shell32.Shell\r\nSet<\/span> oShell = New<\/span> Shell32.Shell<\/pre>\noShell.ShellExecute \"explorer.exe\", _\r\n , , , \"open\", 1<\/pre>\n
oShell.ShellExecute _\r\n \"explorer.exe\", \"c:\\windows\"<\/pre>\n
Shell \"explorer.exe c:\\windows\"<\/pre>\n
Public <\/span>m_Shell As <\/span>Shell32.Shell\r\nPublic Function <\/span>oShell() As <\/span>Shell32.Shell\r\n If <\/span>m_Shell Is Nothing Then<\/span> Set<\/span> m_Shell = New<\/span> Shell32.Shell\r\n Set<\/span> oShell = m_Shell\r\nEnd Function<\/span><\/pre>\nKommandozeilenoptionen<\/h2>\n
Sub <\/span>RunExplorerFolder()\r\n oShell.ShellExecute \"explorer.exe\", \"c:\\windows\", , \"open\", 1\r\nEnd Sub<\/span>\r\nSub <\/span>RunExplorerList()\r\n oShell.ShellExecute \"explorer.exe\", \"\/e,c:\\\", , \"open\", 1\r\nEnd Sub<\/span>\r\nSub <\/span>RunExplorerRoot()\r\n oShell.ShellExecute \"explorer.exe\", \"\/e,\/root,c:\\windows\", , \"open\", 1\r\nEnd Sub<\/span>\r\nSub <\/span>RunExplorerSelectFolder()\r\n oShell.ShellExecute \"explorer.exe\", _\r\n \"\/select,c:\\windows\\system32\", , \"open\", 1\r\nEnd Sub<\/span>\r\nSub <\/span>RunExplorerSelectFile()\r\n oShell.ShellExecute \"explorer.exe\", _\r\n \"\/select,c:\\windows\\system32\\mscomctl.ocx\", , \"open\", 1\r\nEnd Sub<\/span><\/pre>\nSub <\/span>RunExplorerComputer()\r\n oShell.ShellExecute \"explorer.exe\", \",\", , \"open\", 1\r\nEnd Sub<\/span>\r\nSub <\/span>OpenFileExplorer(sFile As String<\/span>)\r\n oShell.ShellExecute \"explorer.exe\", \"\/select,\" & sFile, , \"open\", 1\r\nEnd Sub<\/span>\r\nSub <\/span>RunExplorerSys()\r\n oShell.ShellExecute \"explorer.exe\", _\r\n \"::{21EC2020-3AEA-1069-A2DD-08002B30309D}\", , \"open\", 1\r\nEnd Sub<\/span>\r\nSub <\/span>RunExplorerPrinters()\r\n oShell.ShellExecute \"explorer.exe\", \"\/e,\/root, \" & _\r\n \"::{21ec2020-3aea-1069-a2dd-08002b30309d}\\\" & _\r\n \"::{2227a280-3aea-1069-a2de-08002b30309d}\", , \"open\", 1\r\nEnd Sub<\/span><\/pre>\nShell-NameSpaces<\/h2>\n
Dim <\/span>fld As <\/span>Shell32.Folder\r\nSet<\/span> fld = oShell.NameSpace(\"c:\\\")<\/pre>\nSet<\/span> fld = oShell.NameSpace(\"c:\\\")\r\nDebug.Print<\/span> fld.Title\r\n> \"(C:) Windows 7\"<\/pre>\nSet<\/span> fld = oShell.NameSpace(\"c:\\\")\r\nDebug.Print<\/span> fld.Self.Path\r\n> \"c:\\\"<\/pre>\nDim <\/span>sGUID As String<\/span>\r\nsGUID = \"::{21EC2020-3AEA-1069-A2DD-08002B30309D}\"\r\nSet<\/span> fld = oShell.NameSpace(sGUID)\r\nDebug.Print<\/span> fld.Title\r\n> \"Systemsteuerung\"\r\nDebug.Print<\/span> fld.Self.Path\r\n> \"::{21EC2020-3AEA-1069-A2DD-08002B30309D}\"<\/pre>\nSet<\/span> fld = oShell.NameSpace (0)\r\nDebug.Print<\/span> fld.Title\r\n> \"Desktop\"\r\nDebug.Print<\/span> fld.Self.Path\r\n> \"C:\\Users\\Minhorst\\Desktop\"<\/pre>\nFor i = 0 To 255\r\n Set<\/span> fld = oShell.NameSpace(i)\r\n Debug.Print<\/span> i, fld.Title\r\n Debug.Print<\/span> i, fld.Self.Path\r\nNext<\/span> i<\/pre>\n0 Desktop C:\\Users\\Minhorst\\Desktop\r\n1 Internet ::{871C5380-42A0-1069-A2EA-08002B30309D}\r\n2 Programme C:\\Users\\Minhorst\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\r\n3 Systemsteuerung ::{21EC2020-3AEA-1069-A2DD-08002B30309D}\r\n5 Dokumente C:\\Users\\Sascha\\Documents\r\n...<\/pre>\noShell.ShellExecute _\r\n \"explorer.exe\", _\r\n oShell.NameSpace(0). _\r\n Self.Path<\/pre>\n
![\"](\"..\/fileadmin\/_temp_\/2016_05\/tblShellFolders.png\")
<\/p>\n![\"](\"..\/fileadmin\/_temp_\/2016_05\/rellayout.png\")
<\/p>\n![\"](\"..\/fileadmin\/_temp_\/2016_05\/tblSpecialFolders.png\")
<\/p>\n![\"](\"..\/fileadmin\/_temp_\/2016_05\/tblSpecialSubfolders.png\")
<\/p>\n![\"](\"..\/fileadmin\/_temp_\/2016_05\/tblSpecialItems.png\")
<\/p>\n![\"](\"..\/fileadmin\/_temp_\/2016_05\/subdatasheets.png\")
<\/p>\nShell-Verbs<\/h2>\n
oShell.ShellExecute \"explorer.exe\", , , \"runas\", 1<\/pre>\n
oShell.ShellExecute _\r\n SysCmd(acSysCmdAccessDir) & _\r\n \"msaccess.exe\", , , \"runas\", 1<\/pre>\n
Sub <\/span>SFVerbs()\r\n Dim <\/span>fld As <\/span>Folder\r\n Dim <\/span>itm As <\/span>FolderItem\r\n Dim <\/span>vrb As <\/span>FolderItemVerb\r\n \r\n Set<\/span> fld = oShell.NameSpace(4)\r\n Set<\/span> itm = fld.Items.Item(1)\r\n For Each vrb In itm.Verbs\r\n Debug.Print<\/span> vrb.Name\r\n Next<\/span> vrb\r\nEnd Sub<\/span><\/pre>\nö&ffnen\r\nAls &Standarddrucker festlegen\r\n&Druckeinstellungen...\r\nDrucker &anhalten\r\nFrei&geben...\r\nDrucker &offline verwenden\r\nA&ktualisieren\r\nVe&rknüpfung erstellen\r\n&Löschen\r\n&Umbenennen\r\nE&igenschaften<\/pre>\n
open - öffnen\r\nedit - Bearbeiten\r\ncopy - Kopieren\r\ncut - Ausschneiden\r\nprint - Ausdrucken\r\nrunas - Als Administrator starten\r\nproperties - Eigenschaften anzeigen\r\nfind - Suchen-Dialog anzeigen<\/pre>\n
Sub <\/span>InvokeAVerb()\r\n Dim <\/span>fld As <\/span>Folder\r\n Dim <\/span>itm As <\/span>FolderItem\r\n Dim <\/span>vrb As <\/span>FolderItemVerb\r\n \r\n Set<\/span> fld = oShell.NameSpace(CurrentProject.Path)\r\n Set<\/span> itm = fld.Items.Item(\"sample.txt\")\r\n For Each vrb In itm.Verbs\r\n'''' Debug.Print<\/span> vrb.Name\r\n Next<\/span> vrb\r\n itm.InvokeVerb \"edit\"\r\n itm.InvokeVerb \"properties\"\r\nEnd Sub<\/span><\/pre>\n