5
Vorwort
Endlich ist er da: der Nachfolgeband zum erfolgreichen »Professional Series: Scripting Host Praxisbuch«. In den vergangenen vier Monaten wurde ich von E-Mails förmlich überschüttet, und viele Leser wünschten sich die Quellcodes und Hintergrundinformationen dazu, wie man selbst eigene Script-Befehlserweiterungen schreibt. Genau diese Informationen finden Sie in diesem Buch, und obwohl ich weiß, daß es Ihnen wahrscheinlich in den Fingern juckt, sofort zu den einzelnen Kapiteln zu springen und Resultate zu sehen – bitte gönnen Sie sich und mir drei Minuten, und lesen Sie dieses Vorwort bis zu Ende durch.
Was Sie in diesem Buch finden Dieses Buch setzt nahtlos auf dem Vorgängerband »Professional Series: Scripting Host Praxisbuch« auf. Das bedeutet: Sie finden keine Wiederholungen, sondern durchgängig neue und teilweise unglaubliche Möglichkeiten. Das bedeutet aber auch: Wenn Sie bisher noch keinerlei Berührung mit Scripts gehabt haben, dann ist der Vorgängerband die ideale Einstiegslektüre. Und darum geht es in diesem Buch:
Scripting Spy: Das geheime Script-Spionagetool Wo schlummern eigentlich all die versteckten COM-Objekte, die Ihre Scripts fernsteuern können? Woher weiß man, welche Befehle und Funktionen darin enthalten sind? Wie kann man zum Beispiel Winword fernsteuern oder sich die Rechtschreibkontrolle herausklauben, Windows 2000 eigene Texte vorlesen lassen oder den Akkustand des Notebooks überprüfen? Diese Antworten liefert ein kleines Tool, das Sie auf der Buch-CD finden. Der Scripting Spy durchleuchtet Ihr ganzes System und gewährt dann tiefste Einblicke in den inneren Aufbau aller COM-Objekte, die auf Ihrem System installiert sind. Auf Wunsch schreibt der Scripting Spy sogar Beispielskripte für Sie. Hier eine kleine Kostprobe, die der Scripting Spy ausgegraben hat: Auf Windows 2000-Systemen genügt dieses kleine Script, um Ihrem Computer das Sprechen beizubringen – wenn auch mit ausgeprägt amerikanischem Akzent: ’ VBS Windows Script Host File ’ automatisch generiert von Scripting Spy V1.0 set VTxtAuto = CreateObject("Speech.VoiceText") VTxtAuto.Register "", "Demo App" VTxtAuto.Enabled = true VTxtAuto.Speed = 180
6
Vorwort
text = InputBox("Was soll ich sagen?") VTxtAuto.Speak text, 2 MsgBox "Hören Sie mich?" ' ' ' '
"enabled" ist vom Typ "Property " Zurückgelieferter Wert ist vom Typ: Beschreibung von "enabled" Set the Enabled/Disabled state.
"Long"
Internet Explorer – komplett ausgezogen und offengelegt Internet Explorer im Detail: Der Internet Explorer ist ein enorm mächtiges Programm, denn er ist nicht nur für die Anzeige aller Ordner und Laufwerke verantwortlich, sondern kann auch als Scripting Host-Ausgabefenster genutzt werden. Wie der Internet Explorer hinter den Kulissen funktioniert und an welchen Strippen Ihre Scripts ziehen können, zeige ich Ihnen im Detail. Dabei enthülle ich auch das geheimnisvolle Shell.Application-Objekt, mit dem Sie in laufende ExplorerFenster eingreifen, virtuelle Ordner anzeigen und vieles mehr meistern.
Datenbankzugriffe per Script: Möglichkeiten über Möglichkeiten Entdecken Sie, wie leicht Ihre Scripts per ADODB auf jedwede Datenbank zugreifen, sei es Access, Oracle oder MS SQLServer. Kleine Scripts demonstrieren, wie Sie Daten in Datenbanken schreiben, daraus abfragen und sogar Datenbanken verwalten. Sie können per Script neue Tabellen anlegen, Datenbanken löschen und sogar einen Blick ins ansonsten streng geheime Datenbankschema werfen. Es gibt viel zu entdecken, und das Ergebnis hilft dabei, daß aus Datenbanken keine Datengräber werden. Schreiben Sie sich kleine Konvertierungsskripte, die Datenbankinfos direkt in Excel oder Winword ausgeben, oder lassen Sie Ihre Scripts Textlisten einlesen, die dann sofort in die passende Datenbank geschrieben werden.
Eigene neue Script-Befehle mit der Windows-API Windows-API und eigene Befehlserweiterungen schreiben: Ihnen reichen die eingebauten VBScript-Befehle nicht? Sie wollen die CD-Schublade öffnen, eine Internetverbindung herstellen oder NT-Benutzerkonten anlegen? Dann brauchen Sie Zugriff auf die internen Windows-APIFunktionen, und genau das ist ein ganz besonderer Schwerpunkt dieses Buches. Zuerst zeige ich Ihnen, wie Sie mit der kostenlosen Visual Basic CCE eigene Befehlserweiterungen schreiben. Die VB CCE befindet sich übrigens auf der Buch-CD. Anschließend überschütte ich Sie mit mehr als 30 sofort einsetzbaren Programmierprojekten, die Ihnen auf Anhieb Hunderte neuer Befehle bescheren. Natürlich finden Sie auf der Buch-CD den gesamten Quellcode der Projekte. Sie können also darin herumschmökern, den Quellcode ändern oder für eigene Projekte einsetzen. Die ideale Grundlage für ganz spezielle Kundenlösungen, und die Grundgebühr ist auch schon drin: Ich erhebe keine Lizenzgebühren für die Nutzung der Quellcodes, sofern Sie den Quellcode
Vorwort
7
entweder grundlegend ändern oder zumindest eine Referenz auf dieses Buch einfügen. Klar ist natürlich, daß Sie die Quellcodes nicht für eigene Bücher verwenden dürfen.
ADSI: NT-Benutzerkonten und skriptgesteuerte Administration ADSI ist serienmäßiger Teil von Windows 2000, aber auch kostenlos für Windows NT und Windows 9x nachrüstbar. Mit ADSI bekommen Ihre Scripts mit minimalem Aufwand vollen Zugriff auf lokale und globale Benutzerkonten, Gruppen, Computerdienste und Druckerwarteschlangen. Wer mag, kann so mit einem Zehnzeiler automatisiert Hunderte von neuen Benutzerkonten anlegen oder aber checken, welche Konten seit Ewigkeiten nicht mehr im Einsatz sind. Ein wahres Eldorado für NTSystemadministratoren also. Die ADSI-Scripts sparen Stunden und bisweilen sogar Tage.
WMI – Fernwartung, Ferninstallation und die Script-Zukunft Mit WMI werden Dinge möglich, die bislang schiere Phantasterei waren. WMI verwaltet nämlich nicht nur Ihren eigenen Computer, sondern kann quer über das Netzwerk auch jeden x-beliebigen anderen Computer verwalten. Ob Sie das neueste Microsoft Office-Paket überall in der Firma ferninstallieren wollen, ohne sich dabei aus Ihrem bequemen Ledersessel zu erheben, ob Sie herausfinden wollen, welcher RAM-DAC auf der Grafikkarte des Herrn Müller um die Ecke schuftet, oder ob Sie ferngesteuert Programme auf anderen Computern starten oder beenden wollen – alles ist möglich. Und noch viel mehr: WMI kann sich an Events binden, und Ihre WMI-Scripts könnten so vollautomatisch eine tägliche Liste der Programme anlegen, die in Ihrem Netzwerk gestartet und beendet werden oder bestimmten Personen verbieten, ausgewählte Programme auszuführen. WMI findet mit spielerischer Gelassenheit die MAC-Adressen aller Netzwerkkarten in Ihrem Netzwerk heraus, liefert die Sicherheits-IDs aller Benutzerkonten und kann Systeme sogar ferngesteuert neu starten lassen oder herunterfahren. WMI ist eine neue Technik von Windows 2000, die wie ADSI auch bei Windows NT und 9x kostenlos nachrüstbar ist. Weil WMI so universell einsetzbar ist und so unglaublich viele Informationen liefert, ist es ein zweiter Schwerpunkt dieses Buches. Deshalb finden Sie im Anhang B eine ausgesprochen ausführliche Dokumentation aller WMI-Win32-Klassen. Blättern Sie doch mal hin! Alle Informationen, die Sie dort entdecken, können von Ihren Scripts potentiell erfragt werden. Daneben finden Sie zig interessante neue Befehle, zum Beispiel, um einen Computer herunterzufahren oder neue Programme zu starten.
Was Sie brauchen, um loszuskripten... Bevor Sie irgend etwas anderes tun, sollten Sie auf der Buch-CD den neuesten Scripting Host Version 2.0 (5.1) installieren. Den finden Sie im Ordner WSH als STE51DE.EXE. Nur wer Windows 2000 verwendet, hat diese neueste Version bereits.
8
Vorwort
Diese einfache Datei genügt, um jedes 32-Bit-Windows (95 OSR2.1, 98, NT 4.0) mit dem Windows Scripting Host auszustatten. Einfacher geht’s nicht!
Noch mehr Infos und mein persönliches Angebot Brauchen Sie noch mehr Infos, dann schauen Sie auch mal bei www.wininfo.de/scripting vorbei. Hier bemühe ich mich, in meiner freien Zeit aktuelle Hinweise und Zusatzinfos zu hinterlegen. Falls Sie als Firma Interesse an den neuen Scripting-Möglichkeiten bekommen, aber weder Zeit noch Lust haben, alles selbst zu erforschen: Schulungen zum Thema gibt’s ebenfalls. Wer mag, erreicht mich direkt unter
[email protected]. Diesen Weg sind inzwischen schon viele Firmen gegangen, die per Script wichtige Projekte, Datenanbindungen, Administrationsprobleme und natürlich die Migration zu Windows 2000 meistern. Auch sonst freue ich mich sehr über Ihr Feedback, Anregungen und Ideen. Mailen Sie mir. Haben Sie bitte aber Verständnis dafür, daß ich nicht immer sofort antworten kann.
Blumen, Lob und wichtige Details Schließlich noch etwas in eigener Sache: Mit diesem Buch offenbare ich Ihnen mein gesamtes Know-how zu diesem Thema. Klar ist: Wir befinden uns auf Pionier-Terrain. Bestimmt wird das eine oder andere Script, die eine oder andere Befehlserweiterung noch kleine Macken enthalten. Hier sind Sie gefragt. Nehmen Sie meine Quellcodes und Beispiele als Anregungen, und wenn Sie sie weiterentwickeln, dann halten Sie mich bitte auf dem laufenden. Das gilt natürlich insbesondere für Fehler, die Sie entdecken. Apropos Fehler: Das Spionagetool Scripting Spy habe ich ursprünglich ausschließlich für meine eigene Bequemlichkeit programmiert, spontan in einer rotweinhaltigen Woche in der Provence. Dieses Tool liefert so brisante Informationen, daß ich mich entschlossen habe, es auf die Buch-CD zu geben. Es ist aber kein offizieller Teil des Buches, sondern zusammen mit seiner Beschreibung erst nachträglich ins Manuskript eingewandert. Ich sage dies deshalb so deutlich, weil das Tool nicht auf jedem System lauffähig sein wird. Da das Tool vollautomatisch die Windows-Registry analysiert und dies ein sehr komplexes Unterfangen ist, können defekte Registry-Schlüssel oder Dinge, die ich einfach während der Entwicklung nicht habe erahnen können, zum Programmabbruch führen. Falls ausgerechnet Ihnen das passiert, dann steinigen Sie mich nicht, sondern mailen Sie mir:
[email protected]. Ich bin bemüht, das Tool weiterzuentwickeln, doch dazu brauche ich Ihr Feedback. Eine Garantie für die Funktionsfähigkeit des Tools gebe ich ausdrücklich nicht. Ganz zum Schluß geht mein Dank an die freie Entwicklergemeinde, die im Internet uneigennützig wertvolle Lösungen und Informationen bereitstellt. Scripts und die damit verbundenen Technologien dürfen kein Geheimwissen sein. Diese Informationen gehören auf den Tisch, damit jeder sie nutzen kann. Vor allem aus diesem Grund habe ich mich dazu entschlossen, alle Quellcodes offenzulegen und damit meinen Teil zu tun, um die freie Entwicklergemeinde zu stärken, zu der Sie – hoffentlich – auch bald gehören.
9
Inhaltsverzeichnis 1
Sprachschatz Ihrer Scripts erweitern .................................................................... 27 1.1 1.1.1 1.1.2 1.1.3 1.1.4 1.1.5 1.1.6 1.2 1.2.1 1.2.2 1.3
2
Der Scripting Host – so funktioniert er wirklich ....................................................... 27 Dinge, die Sie kennen sollten.................................................................................. 28 Ein Script starten: das passiert hinter den Kulissen .................................................. 28 WSCRIPT.EXE oder CSCRIPT.EXE? ........................................................................... 31 Internet Explorer als Script Host einsetzen .............................................................. 31 Die besonderen Funktionen des Script Hosts .......................................................... 32 Objekte bereichern Ihren Script-Wortschatz............................................................ 33 Internet Explorer als sinnvoller Script Host .............................................................. 35 Internet Explorer als unsichtbarer Script Host.......................................................... 37 Streng geheim: HTA-Dateien des Internet Explorer 5 .............................................. 37 Scripts um zusätzliche Funktionen bereichern ......................................................... 39
Mit dem Scripting Spy geheime Systemobjekte ausspionieren .................. 41 2.1 2.1.1 2.1.2 2.1.3 2.1.4 2.1.5 2.2 2.2.1 2.3 2.3.1 2.3.2 2.3.3 2.3.4 2.3.5 2.4 2.5 2.6 2.6.1 2.7 2.7.1 2.7.2 2.8 2.8.1 2.8.2 2.8.3
Scripting Spy – das müssen Sie wissen .................................................................... 41 Scripting Spy installieren......................................................................................... 42 Nachschauen, welche Objekte es auf Ihrem System gibt......................................... 42 Detailinformationen zu einem Objekt sehen ........................................................... 45 Wichtige Objekte in die Favoritenliste übernehmen ................................................ 45 Potentiell nutzlose Objekte aus der Liste verbannen................................................ 46 Röntgen-Schirm: Welche Funktionen schlummern in den Objekten?......................... 46 Wie COM-Objekte aufgebaut sind .......................................................................... 47 Nach Informationen suchen ................................................................................... 50 Wo soll gesucht werden? ........................................................................................ 50 Wonach suchen Sie eigentlich?............................................................................... 51 Wie soll gesucht werden – genau oder unscharf?.................................................... 51 Szenario 1: Nach einer ProgID suchen .................................................................... 51 Szenario 2: Nach nützlichen Befehlen suchen ......................................................... 53 Neue Scripting-Funktionen entdecken .................................................................... 53 VBScript und WSH durchleuchten........................................................................... 54 Hilfe zu individuellen Script-Befehlen bekommen.................................................... 55 Geheime Hilfedateien liefern Profi-Informationen.................................................... 56 Vollautomatisch Scripts erstellen............................................................................. 57 Szenario 1: Den Rechner scriptgesteuert herunterfahren ......................................... 57 Szenario 2: Den Inhalt eines Ordners auflisten ........................................................ 60 Fremde Programme per Script fernsteuern ............................................................. 63 Winwords Rechtschreibprüfung für eigene Zwecke nutzen ..................................... 64 Wichtige Dinge, an die Sie denken sollten .............................................................. 66 Noch mehr Automation: Automatisch Texte korrigieren ......................................... 66
10 3
Inhaltsverzeichnis
Die eingebauten WSH-Befehle: Wscript-Objekt ................................................ 69 3.1 3.1.1 3.1.2 3.1.3 3.2 3.2.1 3.2.2 3.3 3.3.1 3.3.2 3.3.3 3.3.4 3.3.5 3.4 3.4.1 3.4.2 3.4.3 3.4.4 3.5 3.5.1 3.5.2 3.5.3 3.5.4
4
Informationen über den Scripting Host................................................................... 69 Das Application-Objekt........................................................................................... 69 Die Version des WSH ermitteln ............................................................................... 70 Pfadnamen und geheime Antworten ...................................................................... 70 Informationen über das Script bekommen .............................................................. 72 Begleitinformation aus dem Scriptordner öffnen..................................................... 72 Logbuch-Datei: Wann und wie oft wird ein Script benutzt? .................................... 73 Drag&Drop: Argumente ans Script übergeben ....................................................... 74 Argumente an Scripts verfüttern ............................................................................. 74 Scripts als DOS-Befehle einsetzen ........................................................................... 75 Mit den DOS-Streams Ein- und Ausgaben ins DOS-Fenster machen........................ 76 Piping – Ergebnisse von anderen Befehlen verfeinern.............................................. 78 Mit Echo: Ergebnisse direkt ans DOS-Fenster .......................................................... 80 Mit Events arbeiten................................................................................................. 81 CreateObject: Geheimtür zu fremden Objekten...................................................... 81 ConnectObject: Eventüberwachung einschalten ..................................................... 83 DisconnectObject: Eventüberwachung ausknipsen ................................................ 83 GetObject: In bestehende Objekte einklinken ......................................................... 84 Scripts anhalten und sofort beenden ...................................................................... 85 Interactive: Alle Benutzerausgaben unterdrücken.................................................... 86 Sleep: Script eine zeitlang anhalten ........................................................................ 86 Quit: Script sofort beenden .................................................................................... 86 Timeout: Script mit eingebauter Notbremse ........................................................... 86
Zugriff auf das Dateisystem: Scripting.FileSystemObject .............................. 89 4.1 4.2 4.2.1 4.2.2 4.2.3 4.2.4 4.2.5 4.2.6 4.2.7 4.2.8 4.2.9 4.2.10 4.2.11 4.2.12 4.2.13 4.2.14 4.2.15 4.2.16 4.2.17 4.2.18
Das Objekt-Modell kennenlernen............................................................................ 89 Allgemeine Befehle des Scripting.FileSystemObject................................................. 90 BuildPath................................................................................................................ 91 CopyFile ................................................................................................................. 91 CopyFolder............................................................................................................. 91 DeleteFile ............................................................................................................... 91 DeleteFolder ........................................................................................................... 92 DriveExists .............................................................................................................. 92 FileExists ................................................................................................................. 92 FolderExists............................................................................................................. 92 GetAbsolutePathName ........................................................................................... 92 GetBaseName......................................................................................................... 93 GetDriveName ....................................................................................................... 93 GetExtensionName................................................................................................. 93 GetFileName .......................................................................................................... 93 GetFileVersion ........................................................................................................ 94 GetParentFolderName ............................................................................................ 94 GetTempName....................................................................................................... 94 MoveFile................................................................................................................. 95 MoveFolder ............................................................................................................ 95
Inhaltsverzeichnis 4.3 4.3.1 4.3.2 4.3.3 4.4 4.4.1 4.4.2 4.4.3 4.4.4 4.4.5 4.4.6 4.4.7 4.4.8 4.4.9 4.4.10 4.4.11 4.4.12 4.5 4.5.1 4.5.2 4.5.3 4.5.4 4.5.5 4.5.6 4.6 4.6.1 4.6.2 4.6.3 4.6.4 4.6.5 4.6.6 4.6.7 4.6.8 4.6.9 4.6.10 4.6.11 4.6.12 4.6.13 4.6.14 4.6.15 4.6.16 4.6.17 4.6.18 4.6.19 4.7 4.7.1
11
Laufwerke managen ............................................................................................... 95 GetDrive – spezifisches Laufwerk heraussuchen....................................................... 95 Drives – alle Laufwerke, die es gibt ......................................................................... 95 Drive – das Laufwerk eines Ordners ........................................................................ 95 Methoden und Eigenschaften des Drive-Objekts..................................................... 96 AvailableSpace........................................................................................................ 96 DriveLetter.............................................................................................................. 97 DriveType............................................................................................................... 97 FileSystem .............................................................................................................. 97 FreeSpace ............................................................................................................... 98 IsReady ................................................................................................................... 98 Path........................................................................................................................ 98 RootFolder.............................................................................................................. 98 SerialNumber ......................................................................................................... 98 ShareName ............................................................................................................ 99 TotalSize................................................................................................................. 99 VolumeName ......................................................................................................... 99 Ordner managen.................................................................................................... 99 CreateFolder......................................................................................................... 101 GetFolder ............................................................................................................. 101 GetSpecialFolder................................................................................................... 101 RootFolder............................................................................................................ 101 ParentFolder ......................................................................................................... 101 Subfolders ............................................................................................................ 102 Eigenschaften des Folder-Objekts ......................................................................... 102 Attributes ............................................................................................................. 103 Copy .................................................................................................................... 104 CreateTextFile....................................................................................................... 104 DateCreated ......................................................................................................... 105 DateLastAccessed ................................................................................................. 106 DateLastModified ................................................................................................. 106 Delete................................................................................................................... 106 Drive .................................................................................................................... 106 Files ...................................................................................................................... 106 IsRootFolder ......................................................................................................... 107 Move.................................................................................................................... 107 Name ................................................................................................................... 107 ParentFolder ......................................................................................................... 107 Path...................................................................................................................... 108 ShortName........................................................................................................... 108 ShortPath ............................................................................................................. 108 Size ...................................................................................................................... 108 SubFolders............................................................................................................ 108 Type ..................................................................................................................... 109 Dateien managen ................................................................................................. 109 GetFile.................................................................................................................. 109
12
Inhaltsverzeichnis 4.7.2 4.8 4.8.1 4.8.2 4.8.3 4.8.4 4.8.5 4.8.6 4.8.7 4.8.8 4.8.9 4.8.10 4.8.11 4.8.12 4.8.13 4.8.14 4.8.15 4.8.16 4.9 4.9.1 4.9.2 4.9.3 4.10 4.10.1 4.10.2 4.10.3 4.10.4 4.10.5 4.10.6 4.10.7 4.10.8 4.10.9 4.10.10 4.10.11 4.10.12 4.10.13
5
Files ...................................................................................................................... 109 Eigenschaften und Methoden des File-Objekts...................................................... 110 Attributes ............................................................................................................. 110 Copy .................................................................................................................... 110 DateCreated ......................................................................................................... 111 DateLastAccessed ................................................................................................. 111 DateLastModified ................................................................................................. 111 Delete................................................................................................................... 111 Drive .................................................................................................................... 112 Move.................................................................................................................... 112 Name ................................................................................................................... 112 OpenAsTextStream............................................................................................... 112 ParentFolder ......................................................................................................... 113 Path...................................................................................................................... 113 ShortName........................................................................................................... 113 ShortPath ............................................................................................................. 113 Size ...................................................................................................................... 113 Type ..................................................................................................................... 114 Dateien neu anlegen, auslesen und verändern ...................................................... 114 CreateTextFile....................................................................................................... 115 OpenTextFile ........................................................................................................ 115 OpenAsTextStream............................................................................................... 116 Eigenschaften und Methoden von TextStreamObject ........................................... 116 AtEndOfLine ......................................................................................................... 116 AtEndOfStream..................................................................................................... 117 Close .................................................................................................................... 117 Column ................................................................................................................ 117 Line ...................................................................................................................... 117 Read ..................................................................................................................... 117 ReadAll ................................................................................................................. 117 ReadLine............................................................................................................... 117 Skip ...................................................................................................................... 118 SkipLine................................................................................................................ 118 Write .................................................................................................................... 118 WriteBlankLines .................................................................................................... 118 WriteLine .............................................................................................................. 118
Zugriff auf die Webansicht: Shell.Application ................................................. 119 5.1 5.2 5.2.1 5.3 5.3.1 5.3.2 5.3.3 5.3.4
Das Objekt-Modell kennenlernen.......................................................................... 119 Die Service-Funktionen des Shell.Application-Objekts ........................................... 120 Versionen und aktuelle Shell-Komponenten.......................................................... 121 Beispielscripts für Shell.Application ....................................................................... 122 CanStartStopService ............................................................................................. 122 CascadeWindows ................................................................................................. 123 ControlPanelItem ................................................................................................. 123 EjectPC ................................................................................................................. 123
Inhaltsverzeichnis 5.3.5 5.3.6 5.3.7 5.3.8 5.3.9 5.3.10 5.3.11 5.3.12 5.3.13 5.3.14 5.3.15 5.3.16 5.3.17 5.3.18 5.3.19 5.3.20 5.3.21 5.3.22 5.3.23 5.3.24 5.3.25 5.3.26 5.3.27
6
13
Explore ................................................................................................................. 123 FileRun ................................................................................................................. 124 FindComputer ...................................................................................................... 124 FindFiles ............................................................................................................... 124 FindPrinter............................................................................................................ 124 GetSystemInformation.......................................................................................... 124 Help ..................................................................................................................... 125 IsRestricted ........................................................................................................... 125 IsServiceRunning .................................................................................................. 126 MinimizeAll .......................................................................................................... 126 Open.................................................................................................................... 126 RefreshMenu ........................................................................................................ 126 ServiceStart .......................................................................................................... 126 ServiceStop........................................................................................................... 127 SetTime ................................................................................................................ 127 ShellExecute ......................................................................................................... 127 ShowBrowserBar................................................................................................... 128 ShutdownWindows .............................................................................................. 128 Suspend ............................................................................................................... 128 TileHorizontally..................................................................................................... 129 TileVertically ......................................................................................................... 129 TrayProperties ...................................................................................................... 129 UndoMinimizeALL ................................................................................................ 129
Zugriff auf die Webansicht: Shell.Application ................................................. 131 6.1 6.1.1 6.2 6.2.1 6.2.2 6.2.3 6.2.4 6.3 6.3.1 6.3.2 6.3.3 6.3.4 6.3.5 6.3.6 6.3.7 6.3.8 6.3.9 6.3.10 6.3.11 6.3.12 6.3.13
Auf Ordner zugreifen: das Folder-Objekt............................................................... 131 Auf ein unsichtbares Folder-Objekt zugreifen ........................................................ 132 Der Inhalt eines Ordners: das FolderItem-Objekt................................................... 134 Direkt ein FolderItem-Objekt ansprechen.............................................................. 134 Mit BrowseForFolder Ordnernamen erfragen ........................................................ 137 Virtuelle Ordner über Codezahlen ansprechen...................................................... 138 Mit GUIDs virtuelle Ordner im Explorer sichtbar machen ...................................... 141 Der innere Aufbau des FolderItem-Objekts............................................................ 144 ExtendedProperty ................................................................................................. 144 GetFolder ............................................................................................................. 154 GetLink................................................................................................................. 155 InvokeVerb ........................................................................................................... 156 InvokeVerbEx........................................................................................................ 159 IsBrowsable .......................................................................................................... 160 IsFileSystem .......................................................................................................... 160 IsFolder................................................................................................................. 160 IsLink .................................................................................................................... 160 ModifyDate .......................................................................................................... 160 Name ................................................................................................................... 160 Parent................................................................................................................... 161 Path...................................................................................................................... 161
14
Inhaltsverzeichnis 6.3.14 6.3.15 6.3.16 6.4 6.4.1 6.4.2 6.4.3 6.4.4 6.4.5 6.4.6 6.4.7 6.4.8 6.4.9 6.4.10 6.4.11 6.4.12 6.4.13 6.4.14 6.4.15 6.5 6.5.1 6.5.2 6.5.3 6.5.4 6.5.5 6.5.6
7
Size ...................................................................................................................... 161 Type ..................................................................................................................... 161 Verbs .................................................................................................................... 161 Der innere Aufbau des Folder-Objekts................................................................... 161 Application ........................................................................................................... 162 CopyHere ............................................................................................................. 162 DismissedWebViewBarricade ................................................................................ 164 GetDetailsOf......................................................................................................... 164 HaveToShowWebViewBarricade............................................................................ 168 Items .................................................................................................................... 168 MoveHere............................................................................................................. 168 NewFolder............................................................................................................ 169 OfflineStatus......................................................................................................... 169 Parent................................................................................................................... 169 ParentFolder ......................................................................................................... 170 ParseName ........................................................................................................... 170 Self ....................................................................................................................... 170 Synchronize.......................................................................................................... 170 Title ...................................................................................................................... 171 Den Explorer fernsteuern: IWebBrowser2.............................................................. 171 Kosmetik: Die Display-Eigenschaften des Explorers steuern ................................... 172 Navigieren: Inhalt im Explorer anzeigen ............................................................... 173 Per Script in den Explorer-Inhalt eingreifen ........................................................... 174 Dateien im Explorer ferngesteuert markieren ........................................................ 175 Eigenschaften-Dialogfenster aufrufen.................................................................... 177 In HTML-Dokumente eingreifen ........................................................................... 178
Eigene Script-Befehlserweiterungen schreiben............................................... 181 7.1 7.1.1 7.1.2 7.1.3 7.1.4 7.1.5 7.1.6 7.2 7.2.1 7.2.2 7.3 7.3.1 7.3.2 7.3.3 7.4 7.4.1 7.4.2 7.4.3
Die Visual Basic CCE startklar machen................................................................... 181 Die VB CCE kennenlernen..................................................................................... 182 Der Project Explorer – Ihr Inhaltsverzeichnis.......................................................... 183 Ihr neues COM-Objekt mit Leben füllen ............................................................... 185 Ihr COM-Objekt testen: Kompilieren .................................................................... 186 Der erste Versuch: Ihren neuen Befehl von Scripts aus ansprechen........................ 187 Die Vorteile neuer COM-Objekte .......................................................................... 188 Die Windows-API verwenden: CD-ROM-Schublade öffnen und schließen ............. 188 Ein neues Projekt starten....................................................................................... 189 Die CD-ROM-Schublade fernsteuern..................................................................... 189 Eigene Dialogfenster entwerfen ............................................................................ 190 Ein Dialogfenster gestalten ................................................................................... 191 Der Test: Ihr eigenes Dialogfenster im Einsatz testen............................................. 197 Wichtige Rahmen-Kosmetik .................................................................................. 198 Ihre neuen COM-Objekte an andere weitergeben................................................. 198 COM-Objekte direkt weitergeben......................................................................... 199 Eigene Setup-Pakete schnüren .............................................................................. 199 Empfehlungen aus der Praxis ................................................................................ 200
Inhaltsverzeichnis
8
15
Programmier-Trickkiste ............................................................................................ 201 8.1 8.1.1 8.2 8.2.1 8.3 8.4 8.5 8.6 8.6.1 8.6.2 8.7 8.7.1 8.7.2 8.8 8.8.1 8.9 8.10 8.11 8.11.1 8.11.2 8.11.3 8.11.4 8.11.5 8.11.6 8.12 8.12.1 8.12.2 8.13 8.13.1 8.13.2 8.13.3 8.13.4 8.13.5 8.13.6 8.13.7 8.13.8 8.14 8.15 8.15.1 8.16 8.16.1 8.17 8.17.1 8.18 8.18.1
Befehlserweiterungen zum Leben erwecken.......................................................... 201 VBP-Projektdateien mit der VB CCE verknüpfen .................................................... 201 Anwendungen zuverlässig in den Vordergrund schalten ....................................... 202 Umschaltsperre abschalten ................................................................................... 202 Bildschirmfotos schießen ...................................................................................... 203 Die Zwischenablage lesen und ändern.................................................................. 205 Echte Laufwerksgrößen – ohne 2 GB Bug! ............................................................ 205 Auswahldialog für Ordner..................................................................................... 206 Flags verwenden – und sogar Dateien aussuchen! ................................................ 207 Virtuelle Ordner – Ihr Dialogfenster spielt mit ....................................................... 208 Icons verwalten – das Icon-Dialogfenster .............................................................. 210 Nach Icons suchen ............................................................................................... 211 Icon-Liste anlegen................................................................................................. 212 Icons konvertieren und verändern......................................................................... 213 System-Icons verändern........................................................................................ 215 Noch ein undokumentiertes Fenster: Disk-Formatierung....................................... 217 Ganz eigene Dialogfenster entwerfen ................................................................... 218 Internet-Zugang automatisieren ........................................................................... 219 Internetverbindungen herstellen und abbauen ..................................................... 220 Zugriff auf FTP-Verzeichnisse ................................................................................ 221 Dateien per FTP herunterladen ............................................................................. 221 Lokale Webseiten auf den Webserver hochladen................................................... 222 Art des Internetzugangs ermitteln......................................................................... 226 Winsock: Hostnamen und IP-Adressen .................................................................. 227 Listen anzeigen mit dem ListView-Tool ................................................................. 228 Listen anlegen und sortieren................................................................................. 228 Listen sortieren, ohne Dialogfenster anzuzeigen ................................................... 230 Multimediageräte fernsteuern............................................................................... 230 Multimediageräte aussuchen ................................................................................ 231 Herausfinden, was das CD-ROM gerade tut .......................................................... 233 Typ der eingelegten CD bestimmen ..................................................................... 233 Details über Musik-CDs erfahren........................................................................... 235 Musik-CDs sekundengenau anspielen ................................................................... 236 MIDI-Dateien spielen ............................................................................................ 237 Video-Dateien anschauen ..................................................................................... 237 Automatisch CD-Tracks in WAV-Dateien verwandeln ............................................ 238 Speicherhaushalt genau beobachten .................................................................... 239 Verschiedene nützliche Systeminformationen ....................................................... 240 Liste der installierten Schriften .............................................................................. 241 Echte unabhängige Dialogfenster generieren........................................................ 241 Dialogfenster mit Fortschrittsanzeige .................................................................... 242 NT-Service-Dienste verwalten ............................................................................... 244 Zustandsbericht aller Dienste................................................................................ 244 Windows herunterfahren – auch remote............................................................... 245 Den eigenen Computer neu starten...................................................................... 245
16
Inhaltsverzeichnis 8.18.2 8.19 8.19.1 8.19.2 8.19.3 8.19.4 8.19.5 8.19.6 8.19.7 8.19.8 8.19.9 8.20 8.20.1 8.20.2 8.21 8.21.1 8.21.2 8.21.3 8.21.4 8.21.5 8.21.6 8.22 8.22.1 8.23 8.23.1 8.23.2 8.23.3 8.23.4 8.23.5 8.23.6 8.23.7 8.24 8.24.1 8.24.2 8.24.3 8.24.4 8.24.5 8.25 8.25.1 8.25.2 8.25.3 8.26 8.26.1 8.27 8.27.1 8.28
Ein System ferngesteuert herunterfahren .............................................................. 246 NT-Benutzerkonten verwalten .............................................................................. 246 Benutzerkonten eines Rechners listen.................................................................... 247 Benutzerkonten filtern .......................................................................................... 247 Neue Benutzerkonten anlegen.............................................................................. 248 Benutzerkonten löschen ....................................................................................... 249 Kennworte ändern................................................................................................ 249 Globale Gruppen auflisten .................................................................................... 249 In welchen Gruppen bin ich Mitglied? .................................................................. 250 Konten in eine Gruppe einfügen........................................................................... 250 Primären Domänencontroller finden..................................................................... 250 Informationen über Ihr Betriebssystem ................................................................. 251 Windows-Version ermitteln................................................................................... 251 Werden bestimmte DLLs bei mir unterstützt? ....................................................... 252 Programme steuern und beenden ........................................................................ 252 Programme starten: der herkömmliche Weg......................................................... 252 Programme per API fernsteuern ............................................................................ 253 Programme per API starten................................................................................... 253 Prüfen, ob ein Programm noch läuft ..................................................................... 255 Warten, bis ein Programm beendet wird .............................................................. 255 Fremde Programme schließen .............................................................................. 255 Eigenschaften-Seiten anzeigen.............................................................................. 256 Eigenschaften von Laufwerken, Dateien, Druckern................................................ 257 Zugriff auf die Registry.......................................................................................... 257 Unterschlüssel auflisten......................................................................................... 258 Einträge in einem Registry-Schlüssel listen ............................................................ 258 Versionsunabhängige Scripts schreiben ................................................................ 259 Variablentyp von Registry-Einträgen herausfinden................................................. 260 Binärdaten lesen und schreiben ............................................................................ 260 Registry-Daten löschen ......................................................................................... 260 Herausfinden, ob es einen bestimmten Schlüssel gibt ........................................... 261 Bildschirmauflösung und Farbtiefe ändern ............................................................ 261 Alle verfügbaren Grafikkarten-Einstellungen sehen ................................................ 262 Aktuelle Grafikkarten-Einstellungen sichtbar machen ............................................ 262 Beste Bildwiederholrate ermitteln ......................................................................... 262 Eine andere Bildwiederholfrequenz einstellen........................................................ 263 Bildschirmauflösung ändern ................................................................................. 263 Dateien kopieren und löschen .............................................................................. 263 TEMP-Dateien in den Papierkorb löschen.............................................................. 264 Papierkorb löschen ............................................................................................... 265 Backups anlegen................................................................................................... 265 Icons im Gerätefeld der Taskleiste anzeigen .......................................................... 267 Scripts per Taskleisten-Icon steuern....................................................................... 267 Versionsinformationen über Dateien erhalten ....................................................... 268 Informationen über Dateien herausfinden............................................................. 268 Eigene HTML-Dialogfenster verwenden ............................................................... 269
Inhaltsverzeichnis 8.28.1 8.28.2 8.28.3 8.28.4 8.28.5 8.28.6
9
17
Einfache HTML-Dialogfenster verwenden.............................................................. 269 Schaltflächen mit Scriptprozeduren verbinden...................................................... 271 Kommunikation zwischen HTML-Vorlage und Script............................................. 272 Luxus-Optionen für HTML-Dialoge ....................................................................... 274 Formulareingaben prüfen ..................................................................................... 276 Optionsfelder verwenden ..................................................................................... 277
Auf Datenbanken zugreifen: Universal Data Access ...................................... 279 9.1 9.1.1 9.1.2 9.2 9.2.1 9.2.2 9.2.3 9.3 9.3.1 9.3.2 9.4 9.4.1 9.4.2 9.4.3 9.5 9.5.1 9.6 9.7 9.7.1 9.7.2 9.7.3 9.7.4 9.7.5 9.8 9.8.1 9.8.2 9.8.3 9.9 9.10 9.10.1 9.10.2
Wie kommt man an ADO DB heran? .................................................................... 279 ADO DB Versionsdschungel: So blicken Sie durch................................................. 281 ADO DB-Version bestimmen: die Zweite............................................................... 282 Informationen aus einer Datenbank auslesen ........................................................ 282 Den Inhalt einer Datenbank auflisten .................................................................... 283 Eigene Daten in die Datenbank einfügen .............................................................. 284 Daten aus der Datenbank löschen ........................................................................ 285 Wie’s funktioniert: ADO DB auf die Finger geschaut ............................................. 286 Eine Datenbankverbindung herstellen................................................................... 286 Mit SQL die Datenbank »bedienen« ..................................................................... 287 SELECT: Daten auswählen..................................................................................... 287 Nur ganz bestimmte Datensätze herausfischen..................................................... 287 Datenbank-Ergebnis sortieren ............................................................................... 288 Wichtige Fallen rund um SELECT .......................................................................... 288 INSERT INTO: Neue Daten in die Datenbank schreiben ........................................ 288 Tücken rund um INSERT INTO ............................................................................. 289 DELETE – Informationen aus der Datenbank streichen .......................................... 290 Die innere Struktur einer Datenbank aufdecken .................................................... 290 Feldnamen sichtbar machen................................................................................. 290 Variablentypen der Felder entschlüsseln................................................................ 291 Alle Tabellen in der Datenbank auflisten ............................................................... 292 Das Schema: So kommen Sie an Infos heran......................................................... 293 Na also: Systemtabellen von normalen Tabellen unterscheiden ............................ 294 Eigene Tabellen anlegen ....................................................................................... 296 Alle Tabellen in einer Datenbank löschen.............................................................. 296 Eigene neue Datenbank-Tabellen anlegen ............................................................ 297 Das steckt dahinter: Variablentypen auflisten ........................................................ 300 Die innere Struktur Ihrer Datenbankzugriffe.......................................................... 301 System-DSN: Datenbanken systemweit administrieren ......................................... 303 Eine neue System-Datenbank anlegen .................................................................. 303 Auf eine DSN-Datenbank zugreifen ...................................................................... 305
10 ADSI: Netzwerk und Benutzerkonten verwalten ............................................ 307 10.1 10.1.1 10.2 10.2.1 10.3
ADSI – die Geheimtür in die Netzwerkwelt aufstoßen ........................................... 307 Welche Datenquellen kann ADSI sichtbar machen? .............................................. 308 WinNT: Computerverwaltung par excellence........................................................ 308 Alle Computer auflisten, die momentan online sind.............................................. 309 Spionage: Welche Informationen liefert ein Objekt eigentlich?.............................. 310
18
Inhaltsverzeichnis 10.3.1 10.3.2 10.4 10.4.1 10.4.2 10.4.3 10.5 10.5.1 10.5.2 10.6 10.6.1 10.6.2 10.6.3 10.6.4 10.7 10.7.1 10.7.2 10.7.3 10.7.4 10.7.5 10.7.6 10.7.7 10.7.8 10.7.9 10.7.10 10.7.11 10.7.12 10.8 10.8.1 10.8.2 10.8.3 10.8.4 10.8.5 10.8.6 10.8.7 10.9 10.9.1 10.9.2 10.9.3 10.9.4 10.9.5 10.10 10.10.1 10.10.2 10.10.3 10.10.4
Domänen-Informationen ausfragen ...................................................................... 312 Standardeigenschaften der Domäne ändern ......................................................... 313 Das Schema: »Bedienungsanleitung« eines Objekts .............................................. 314 Welche Objekte gibt es eigentlich? ....................................................................... 316 Den Typ eines beliebigen Objekts herausfinden .................................................... 317 Objekte und deren Inhalt managen ...................................................................... 318 ADSI-Fehler: Wissen, was schiefläuft...................................................................... 318 Wichtige ADSI-Fehler abfangen ............................................................................ 318 Fehlerursachen direkt erfragen: eigene Befehlserweiterung ................................... 321 Informationen über Computer erfragen................................................................ 324 Alle Computer sehen, die gerade online sind ........................................................ 324 Details über Computer erfragen ........................................................................... 324 Hardware-Inventurliste erstellen............................................................................ 325 Alle Drucker im Netzwerk auflisten ....................................................................... 326 Benutzerkonten verwalten .................................................................................... 327 Alle Benutzerkonten eines Computers auflisten ..................................................... 327 Ein neues Benutzerkonto anlegen ......................................................................... 329 Benutzerkonten wieder entfernen ......................................................................... 330 Kennwörter ändern .............................................................................................. 331 Spezielle Einstellungen des Benutzerkontos setzen ................................................ 334 Wie lange ist ein Kennwort bereits in Benutzung?................................................. 336 Wann hat ein Benutzer sich das letzte Mal eingeloggt?......................................... 338 Details der Benutzerkonten selbst festlegen .......................................................... 339 Benutzer-Flags des Kontos setzen ......................................................................... 340 Ein Konto sperren ................................................................................................. 341 Beim nächsten Einloggen Kennwortänderung erzwingen ..................................... 344 Kennwortänderungen verbieten ........................................................................... 344 Gruppen-Verwaltung............................................................................................ 345 Welche Gruppen gibt es überhaupt? .................................................................... 345 Welche Eigenschaften bieten Gruppen-Objekte? .................................................. 346 In welchen Gruppen ist ein Benutzer Mitglied?..................................................... 347 Eine neue Benutzergruppe anlegen ...................................................................... 349 Benutzerkonten in die neue Gruppe einfügen....................................................... 350 Benutzer aus einer Gruppe entfernen.................................................................... 352 Benutzergruppen löschen ..................................................................................... 352 Services – Windows-Dienste verwalten.................................................................. 352 Welche Dienste laufen gerade? ............................................................................. 353 Welche Eigenschaften bieten Dienste? .................................................................. 353 Zustandsbericht über alle Dienste erstellen ........................................................... 354 Einen Dienst starten oder beenden ....................................................................... 360 Das Startverhalten von Diensten ändern ............................................................... 361 Freigegebene Ordner verwalten............................................................................ 362 Alle freigegebenen Ordner auflisten...................................................................... 362 Einen neuen freigegebenen Ordner anlegen......................................................... 365 Eine Freigabe rückgängig machen ........................................................................ 366 Schauen, wer welche Freigaben zur Zeit nutzt ...................................................... 366
Inhaltsverzeichnis 10.11 10.11.1 10.11.2 10.11.3 10.11.4 10.11.5 10.11.6
19
Netzwerkdrucker – Druckaufträge managen ......................................................... 368 Welche Drucker stehen im Netzwerk zur Verfügung?............................................ 369 Die Eigenschaften der Drucker-Warteschlangen .................................................... 369 Wie geht es meinem Drucker? Ein Statusreport..................................................... 371 Die Aufträge eines Druckers sichtbar machen ....................................................... 372 Druckerwarteschlange komplett löschen............................................................... 374 Priorität einzelner Druckaufträge ändern............................................................... 374
11 WMI: Computerverwaltung lokal und quer durchs Netz ............................ 377 11.1 11.1.1 11.2 11.2.1 11.2.2 11.2.3 11.2.4 11.2.5 11.2.6 11.3 11.3.1 11.3.2 11.3.3 11.4 11.4.1 11.4.2 11.4.3 11.4.4 11.4.5 11.4.6 11.5 11.5.1 11.5.2
WMI und WBEM: Ihre ultimative Allzweckwaffe .................................................... 377 So geht’s: Mit WMI fremde Computer untersuchen.............................................. 377 WMI startklar machen: So läuft die Sache rund..................................................... 379 Der Fahrplan: So werden Sie zum WMI-Profi......................................................... 380 WMI nachrüsten ................................................................................................... 380 Der erste Test: Funktioniert WMI?......................................................................... 381 Ferngesteuert auf WMI zugreifen .......................................................................... 382 Windows 95/98 – WMI total trotz eingebauter Sperren ........................................ 383 Wichtige Details, die Sie kenen sollten .................................................................. 385 Grundlagen: So kommen Sie an WMI-Informationen............................................ 385 Weitere Möglichkeiten, um an WMI-Informationen zu gelangen .......................... 386 Netzwerkzugriffe: WMI ferngesteuert ................................................................... 386 Informationen mit SQL abfragen .......................................................................... 387 Endlich verständlich: Einsatz von Monikern........................................................... 388 Mit dem WMI-Dienst verbinden – lokal und remote ............................................. 388 WMI-Namespace festlegen ................................................................................... 388 Direkt mit WMI-Geräteklassen verbinden .............................................................. 389 Bestimmte Geräte und Klassen direkt ansprechen ................................................. 390 Spezialoperationen: Sonderrechte aktivieren......................................................... 391 Impersonation: Herausfinden, wer die WMI-Aktion verantwortet .......................... 392 Welche Informationen hat WMI auf Lager? ........................................................... 393 Liste erstellen: Diese Klassen unterstützt WMI ....................................................... 393 Alle Informationen über eine Klasse finden............................................................ 394
12 Mit WMI-Klassen arbeiten ....................................................................................... 403 12.1 12.1.1 12.2 12.2.1 12.2.2 12.2.3 12.2.4 12.3 12.3.1 12.3.2 12.3.3 12.3.4
Mit Win32_OperatingSystem experimentieren ..................................................... 403 Einen Computer herunterfahren (oder neu starten) .............................................. 404 Programme ferngesteuert starten ......................................................................... 406 Welche Programme laufen gerade? ...................................................................... 406 Alle Infos über Prozesse anzeigen.......................................................................... 407 Programme ferngesteuert starten ......................................................................... 409 Programme ferngesteuert beenden ...................................................................... 410 Programme ferngesteuert installieren ................................................................... 410 Ferninstallation – was sind die Voraussetzungen?.................................................. 411 Ferngesteuert Programmpakete installieren .......................................................... 411 Programme ferngesteuert deinstallieren................................................................ 412 Asynchrone Programminstallation und -Deinstallation .......................................... 413
20
Inhaltsverzeichnis 12.4 12.4.1 12.4.2 12.4.3
A
Auf der Buch-CD ......................................................................................................... 427 A.1 A.2 A.3 A.4 A.5 A.6
B
Mit WMI auf System-Ereignisse reagieren ............................................................. 416 Auf Events warten................................................................................................. 417 Programmstarts protokollieren.............................................................................. 418 Sinnvolle Management-Tools entwickeln .............................................................. 421
Scripting Host und Zubehör ................................................................................. 427 Scripting Spy – Das Spionagetool ......................................................................... 427 Scriptbeispiele öffnen statt abtippen..................................................................... 428 Visual Basic-Entwicklungsumgebung..................................................................... 428 Programmierprojekte en masse............................................................................. 428 WMI – Tools für wahres WMI-Vergnügen ............................................................. 428
WMI Klassenreferenz ................................................................................................ 429 B.1 B.2 B.3 B.4 B.5 B.6 B.7 B.8 B.9 B.10 B.11 B.12 B.13 B.14 B.15 B.16 B.17 B.18 B.19 B.20 B.21 B.22 B.23 B.24 B.25 B.26 B.27 B.28 B.29 B.30 B.31 B.32 B.33
Wie Sie diese Referenz nutzen............................................................................... 429 Win32_1394Controller ......................................................................................... 429 Win32_1394ControllerDevice............................................................................... 432 Win32_ACE .......................................................................................................... 432 Win32_Account.................................................................................................... 432 Win32_AccountSID............................................................................................... 433 Win32_AllocatedResource..................................................................................... 434 Win32_ApplicationCommandLine ........................................................................ 434 Win32_ApplicationService .................................................................................... 434 Win32_AssociatedBattery...................................................................................... 435 Win32_AssociatedProcessorMemory ..................................................................... 435 Win32_BIOS ......................................................................................................... 435 Win32_BaseBoard................................................................................................. 437 Win32_BaseService ............................................................................................... 440 Win32_Battery...................................................................................................... 453 Win32_Binary ....................................................................................................... 456 Win32_BindImageAction ...................................................................................... 456 Win32_BootConfiguration .................................................................................... 457 Win32_Bus ........................................................................................................... 457 Win32_CDROMDrive............................................................................................ 460 Win32_CIMLogicalDeviceCIMDataFile .................................................................. 464 Win32_COMApplication....................................................................................... 464 Win32_COMApplicationClasses ............................................................................ 465 Win32_COMApplicationSettings .......................................................................... 465 Win32_COMClass................................................................................................. 465 Win32_COMSetting ............................................................................................. 466 Win32_CacheMemory .......................................................................................... 466 Win32_CheckCheck.............................................................................................. 471 Win32_ClassInfoAction ......................................................................................... 471 Win32_ClassicCOMApplicationClasses.................................................................. 472 Win32_ClassicCOMClass ...................................................................................... 472 Win32_ClassicCOMClassSetting ........................................................................... 473 Win32_ClassicCOMClassSettings .......................................................................... 475
Inhaltsverzeichnis B.34 B.35 B.36 B.37 B.38 B.39 B.40 B.41 B.42 B.43 B.44 B.45 B.46 B.47 B.48 B.49 B.50 B.51 B.52 B.53 B.54 B.55 B.56 B.57 B.58 B.59 B.60 B.61 B.62 B.63 B.64 B.65 B.66 B.67 B.68 B.69 B.70 B.71 B.72 B.73 B.74 B.75 B.76 B.77 B.78 B.79 B.80 B.81
21
Win32_ClientApplicationSetting ........................................................................... 475 Win32_CodecFile.................................................................................................. 475 Win32_ComClassAutoEmulator ............................................................................ 481 Win32_ComClassEmulator.................................................................................... 481 Win32_CommandLineAccess................................................................................ 482 Win32_ComponentCategory................................................................................ 482 Win32_ComputerSystem...................................................................................... 483 Win32_ComputerSystemProcessor ....................................................................... 487 Win32_ComputerSystemProduct.......................................................................... 487 Win32_Condition ................................................................................................. 488 Win32_CreateFolderAction ................................................................................... 488 Win32_CurrentProbe............................................................................................ 489 Win32_DCOMApplication .................................................................................... 492 Win32_DCOMApplicationAccessAllowedSetting ................................................... 493 Win32_DCOMApplicationLaunchAllowedSetting.................................................. 493 Win32_DCOMApplicationSetting ......................................................................... 493 Win32_DMAChannel............................................................................................ 494 Win32_DependentService .................................................................................... 495 Win32_Desktop .................................................................................................... 495 Win32_DesktopMonitor ....................................................................................... 497 Win32_DeviceBus ................................................................................................. 499 Win32_DeviceMemoryAddress ............................................................................. 500 Win32_DeviceSettings .......................................................................................... 500 Win32_Directory .................................................................................................. 501 Win32_DirectorySpecification............................................................................... 506 Win32_DiskDrive .................................................................................................. 507 Win32_DiskDriveToDiskPartition........................................................................... 512 Win32_DiskPartition ............................................................................................. 512 Win32_DisplayConfiguration ................................................................................ 515 Win32_DisplayControllerConfiguration................................................................. 516 Win32_DriverVXD ................................................................................................ 517 Win32_DuplicateFileAction ................................................................................... 519 Win32_Environment ............................................................................................. 520 Win32_EnvironmentSpecification ......................................................................... 521 Win32_ExtensionInfoAction .................................................................................. 521 Win32_Fan ........................................................................................................... 522 Win32_FileSpecification ........................................................................................ 525 Win32_FloppyController....................................................................................... 526 Win32_FloppyDrive .............................................................................................. 529 Win32_FontInfoAction.......................................................................................... 532 Win32_Group....................................................................................................... 532 Win32_GroupUser ................................................................................................ 533 Win32_HeatPipe ................................................................................................... 533 Win32_IDEController ............................................................................................ 536 Win32_IDEControllerDevice.................................................................................. 538 Win32_IRQResource ............................................................................................. 538 Win32_ImplementedCategory.............................................................................. 540 Win32_InfraredDevice .......................................................................................... 540
22
Inhaltsverzeichnis B.82 B.83 B.84 B.85 B.86 B.87 B.88 B.89 B.90 B.91 B.92 B.93 B.94 B.95 B.96 B.97 B.98 B.99 B.100 B.101 B.102 B.103 B.104 B.105 B.106 B.107 B.108 B.109 B.110 B.111 B.112 B.113 B.114 B.115 B.116 B.117 B.118 B.119 B.120 B.121 B.122 B.123 B.124 B.125 B.126 B.127 B.128 B.129
Win32_IniFileSpecification .................................................................................... 542 Win32_InstalledSoftwareElement.......................................................................... 543 Win32_Keyboard .................................................................................................. 544 Win32_LaunchCondition ...................................................................................... 546 Win32_LoadOrderGroup ...................................................................................... 547 Win32_LoadOrderGroupServiceDependencies...................................................... 547 Win32_LoadOrderGroupServiceMembers ............................................................. 548 Win32_LogicalDisk ............................................................................................... 548 Win32_LogicalDiskRootDirectory .......................................................................... 551 Win32_LogicalDiskToPartition .............................................................................. 551 Win32_LogicalFileAccess....................................................................................... 552 Win32_LogicalFileAuditing ................................................................................... 552 Win32_LogicalFileGroup....................................................................................... 552 Win32_LogicalFileOwner ...................................................................................... 553 Win32_LogicalFileSecuritySetting ......................................................................... 553 Win32_LogicalMemoryConfiguration ................................................................... 553 Win32_LogicalProgramGroup............................................................................... 554 Win32_LogicalProgramGroupDirectory ................................................................ 554 Win32_LogicalProgramGroupItem........................................................................ 554 Win32_LogicalProgramGroupItemDataFile ........................................................... 555 Win32_LogicalShareAccess ................................................................................... 555 Win32_LogicalShareAuditing ................................................................................ 555 Win32_LogicalShareSecuritySetting ...................................................................... 556 Win32_MIMEInfoAction........................................................................................ 556 Win32_MSIResource ............................................................................................. 557 Win32_MemoryArray ........................................................................................... 557 Win32_MemoryArrayLocation .............................................................................. 561 Win32_MemoryDevice ......................................................................................... 561 Win32_MemoryDeviceArray ................................................................................. 565 Win32_MemoryDeviceLocation ............................................................................ 565 Win32_MotherboardDevice.................................................................................. 565 Win32_MoveFileAction ......................................................................................... 567 Win32_NTEventlogFile ......................................................................................... 568 Win32_NetworkAdapter ....................................................................................... 575 Win32_NetworkAdapterConfiguration.................................................................. 577 Win32_NetworkAdapterSetting ............................................................................ 598 Win32_NetworkClient .......................................................................................... 599 Win32_NetworkConnection ................................................................................. 599 Win32_NetworkLoginProfile ................................................................................. 600 Win32_NetworkProtocol ...................................................................................... 604 Win32_ODBCAttribute ......................................................................................... 606 Win32_ODBCDataSourceAttribute ....................................................................... 606 Win32_ODBCDataSourceSpecification.................................................................. 606 Win32_ODBCDriverSoftwareElement.................................................................... 607 Win32_ODBCDriverSpecification .......................................................................... 607 Win32_ODBCSourceAttribute............................................................................... 608 Win32_ODBCTranslatorSpecification .................................................................... 608 Win32_OSRecoveryConfiguration......................................................................... 609
Inhaltsverzeichnis B.130 B.131 B.132 B.133 B.134 B.135 B.136 B.137 B.138 B.139 B.140 B.141 B.142 B.143 B.144 B.145 B.146 B.147 B.148 B.149 B.150 B.151 B.152 B.153 B.154 B.155 B.156 B.157 B.158 B.159 B.160 B.161 B.162 B.163 B.164 B.165 B.166 B.167 B.168 B.169 B.170 B.171 B.172 B.173 B.174 B.175 B.176 B.177
23
Win32_OnBoardDevice ........................................................................................ 610 Win32_OperatingSystem...................................................................................... 612 Win32_OperatingSystemQFE................................................................................ 617 Win32_PCMCIAController .................................................................................... 617 Win32_PNPAllocatedResource .............................................................................. 619 Win32_POTSModem ............................................................................................ 619 Win32_POTSModemToSerialPort.......................................................................... 625 Win32_PageFile .................................................................................................... 625 Win32_PageFileElementSetting............................................................................. 631 Win32_PageFileSetting ......................................................................................... 632 Win32_PageFileUsage........................................................................................... 632 Win32_ParallelPort ............................................................................................... 633 Win32_Patch ........................................................................................................ 635 Win32_PatchFile ................................................................................................... 635 Win32_PatchPackage ........................................................................................... 636 Win32_PhysicalMemory ....................................................................................... 636 Win32_PhysicalMemoryArray ............................................................................... 638 Win32_PhysicalMemoryLocation .......................................................................... 640 Win32_PnPDevice ................................................................................................ 640 Win32_PnPEntity .................................................................................................. 641 Win32_PointingDevice ......................................................................................... 643 Win32_PortConnector .......................................................................................... 646 Win32_PortResource............................................................................................. 647 Win32_PortableBattery ......................................................................................... 648 Win32_PowerManagementEvent.......................................................................... 652 Win32_PrintJob .................................................................................................... 652 Win32_Printer ...................................................................................................... 654 Win32_PrinterConfiguration ................................................................................. 657 Win32_PrinterController ....................................................................................... 660 Win32_PrinterDriverDll ......................................................................................... 660 Win32_PrinterSetting ........................................................................................... 660 Win32_PrinterShare .............................................................................................. 660 Win32_PrivilegesStatus ......................................................................................... 661 Win32_Process ..................................................................................................... 661 Win32_ProcessStartup .......................................................................................... 666 Win32_Processor .................................................................................................. 669 Win32_Product..................................................................................................... 673 Win32_ProductCheck ........................................................................................... 675 Win32_ProductResource....................................................................................... 675 Win32_ProductSoftwareFeatures .......................................................................... 675 Win32_ProgIDSpecification .................................................................................. 676 Win32_ProgramGroup ......................................................................................... 676 Win32_ProgramGroupContents ........................................................................... 677 Win32_ProgramGroupOrItem .............................................................................. 677 Win32_Property ................................................................................................... 677 Win32_ProtocolBinding ........................................................................................ 677 Win32_PublishComponentAction ......................................................................... 678 Win32_QuickFixEngineering ................................................................................. 678
24
Inhaltsverzeichnis B.178 B.179 B.180 B.181 B.182 B.183 B.184 B.185 B.186 B.187 B.188 B.189 B.190 B.191 B.192 B.193 B.194 B.195 B.196 B.197 B.198 B.199 B.200 B.201 B.202 B.203 B.204 B.205 B.206 B.207 B.208 B.209 B.210 B.211 B.212 B.213 B.214 B.215 B.216 B.217 B.218 B.219 B.220 B.221 B.222 B.223 B.224 B.225
Win32_Refrigeration ............................................................................................. 679 Win32_Registry .................................................................................................... 682 Win32_RegistryAction........................................................................................... 682 Win32_RemoveFileAction ..................................................................................... 684 Win32_RemoveIniAction....................................................................................... 684 Win32_ReserveCost .............................................................................................. 685 Win32_SCSIController .......................................................................................... 686 Win32_SCSIControllerDevice................................................................................ 689 Win32_SID ........................................................................................................... 689 Win32_SMBIOSMemory ....................................................................................... 690 Win32_ScheduledJob............................................................................................ 693 Win32_SecurityDescriptor .................................................................................... 696 Win32_SecuritySetting ......................................................................................... 697 Win32_SecuritySettingAccess ............................................................................... 697 Win32_SecuritySettingAuditing ............................................................................ 697 Win32_SecuritySettingGroup................................................................................ 697 Win32_SecuritySettingOfLogicalFile...................................................................... 698 Win32_SecuritySettingOfLogicalShare .................................................................. 698 Win32_SecuritySettingOfObject ........................................................................... 698 Win32_SecuritySettingOwner ............................................................................... 698 Win32_SelfRegModuleAction................................................................................ 698 Win32_SerialPort .................................................................................................. 699 Win32_SerialPortConfiguration............................................................................. 703 Win32_SerialPortSetting ....................................................................................... 706 Win32_Service...................................................................................................... 706 Win32_ServiceControl .......................................................................................... 711 Win32_ServiceSpecification .................................................................................. 712 Win32_ServiceSpecificationService ....................................................................... 713 Win32_SettingCheck ............................................................................................ 713 Win32_Share ........................................................................................................ 713 Win32_ShareToDirectory ...................................................................................... 716 Win32_ShortcutAction.......................................................................................... 716 Win32_ShortcutFile .............................................................................................. 717 Win32_ShortcutSAP.............................................................................................. 722 Win32_SoftwareElement....................................................................................... 723 Win32_SoftwareElementAction............................................................................. 724 Win32_SoftwareElementCheck ............................................................................. 724 Win32_SoftwareElementCondition ....................................................................... 725 Win32_SoftwareElementResource ......................................................................... 725 Win32_SoftwareFeature........................................................................................ 726 Win32_SoftwareFeatureAction.............................................................................. 727 Win32_SoftwareFeatureCheck .............................................................................. 727 Win32_SoftwareFeatureParent .............................................................................. 727 Win32_SoftwareFeatureSoftwareElements ............................................................ 727 Win32_SoundDevice ............................................................................................ 728 Win32_StartupCommand..................................................................................... 730 Win32_SubDirectory ............................................................................................ 730 Win32_SystemAccount......................................................................................... 730
Inhaltsverzeichnis B.226 B.227 B.228 B.229 B.230 B.231 B.232 B.233 B.234 B.235 B.236 B.237 B.238 B.239 B.240 B.241 B.242 B.243 B.244 B.245 B.246 B.247 B.248 B.249 B.250 B.251 B.252 B.253 B.254 B.255 B.256 B.257 B.258 B.259 B.260 B.261 B.262 B.263 B.264
25
Win32_SystemBIOS .............................................................................................. 731 Win32_SystemBootConfiguration ......................................................................... 732 Win32_SystemDesktop ......................................................................................... 732 Win32_SystemDevices .......................................................................................... 732 Win32_SystemDriver ............................................................................................ 732 Win32_SystemDriverPNPEntity ............................................................................. 737 Win32_SystemEnclosure ....................................................................................... 737 Win32_SystemLoadOrderGroups.......................................................................... 740 Win32_SystemLogicalMemoryConfiguration ........................................................ 740 Win32_SystemMemoryResource........................................................................... 740 Win32_SystemNetworkConnections ..................................................................... 741 Win32_SystemOperatingSystem........................................................................... 741 Win32_SystemPartitions ....................................................................................... 742 Win32_SystemProcesses ....................................................................................... 742 Win32_SystemProgramGroups ............................................................................. 742 Win32_SystemResources....................................................................................... 742 Win32_SystemServices ......................................................................................... 742 Win32_SystemSetting........................................................................................... 743 Win32_SystemSlot................................................................................................ 743 Win32_SystemSystemDriver ................................................................................. 745 Win32_SystemTimeZone ...................................................................................... 745 Win32_SystemUsers ............................................................................................. 745 Win32_TapeDrive ................................................................................................. 746 Win32_TemperatureProbe.................................................................................... 749 Win32_Thread...................................................................................................... 752 Win32_TimeZone ................................................................................................. 754 Win32_Trustee ..................................................................................................... 755 Win32_TypeLibraryAction..................................................................................... 756 Win32_USBController ........................................................................................... 756 Win32_USBControllerDevice................................................................................. 759 Win32_UninterruptiblePowerSupply ..................................................................... 759 Win32_UserAccount ............................................................................................. 763 Win32_UserDesktop ............................................................................................. 765 Win32_VideoConfiguration .................................................................................. 765 Win32_VideoController ........................................................................................ 767 Win32_VideoSettings............................................................................................ 771 Win32_VoltageProbe ............................................................................................ 771 Win32_WMIElementSetting.................................................................................. 774 Win32_WMISetting .............................................................................................. 775
Stichwortverzeichnis ................................................................................................. 779
27
1
Sprachschatz Ihrer Scripts erweitern
Woher kommt die »Intelligenz« und Macht Ihrer Scripts? Wer bestimmt, was Sie mit Scripts tun können – und was nicht? Wie erweitern Sie Macht und Einfluß Ihrer Scripts und fügen genau die Funktionen hinzu, die Sie gerade brauchen? Lesen Sie in diesem Kapitel, was wirklich hinter Scripts steckt und wie Sie in nur wenigen Minuten Ihren Scripts jede noch so exotische Windows-Funktion beibringen – oder einfach nur die CD-ROM-Schublade auf- und zuklappen.
1.1
Der Scripting Host – so funktioniert er wirklich
Am besten schauen Sie sich einfach in Zeitlupe an, was passiert, wenn Sie ein Script auf Ihrem Computer ausführen. So wird sofort klar, wer alles daran beteiligt ist – und welche enormen Erweiterungsmöglichkeiten sich dadurch bieten!
Bild 1.1: Scripts sind ganz normale Textdateien
Dafür benötigen Sie zuerst als Versuchskaninchen ein einfaches Script: 1. Starten Sie den Texteditor: im Startmenü wählen Sie Ausführen und geben ein: NOTEPAD [Enter]. 2. Geben Sie nun das folgende Beispielscript ein: MsgBox WScript.ScriptFullName
3. Speichern Sie dieses Script: wählen Sie im Datei-Menü Speichern unter, stellen Sie oben in der Ausklappliste Speichern in ein: Desktop, und speichern Sie das Script als test.vbs [Enter]. Ganz wichtig: hängen Sie an den Dateinamen die Extension .vbs an! 4. Schließen Sie dann den Editor. Fertig. Auf Ihrem Desktop liegt nun ein Beispielscript.
28
Kapitel 1: Sprachschatz Ihrer Scripts erweitern
Bild 1.2: Textdateien mit der Extension VBS verwandeln sich in ausführbare Scripts
1.1.1
Dinge, die Sie kennen sollten...
Und was, wenn das Beispiel nicht auf Anhieb klappen sollte? Hier die wichtigsten Lösungen aus der Praxis: • Liegt auf Ihrem Desktop nur eine ganz normale Textdatei, die nicht das typische Script-Icon trägt? Dann ist auf Ihrem System der Scripting Host noch nicht installiert. Holen Sie das kurz nach, und starten Sie dazu auf der Buch-CD im Verzeichnis WSH das Programm STE51DE. EXE. Der Scripting Host wird installiert, und spätestens nach einem Neustart funktionieren Ihre Scripts wie geplant. • Sie haben sich vertippt und wollen den Inhalt des Scripts nachträglich verändern? Dann klicken Sie mit der rechten Maustaste auf die Scriptdatei und wählen Bearbeiten. Schon wird Ihnen der Script-Text zur Bearbeitung vorgelegt. Speichern Sie Änderungen im Datei-Menü mit Speichern. • Sie wollen genauer wissen, wo Fehler in Ihrem Script liegen? Dann installieren Sie den ScriptDebugger. Den finden Sie auf der Buch-CD im Ordner WSH als DEBUGGER9x.EXE (für Windows 95 und 98) und DEBUGGERNT.EXE (für Windows NT und 2000). Tip: WSH auf neuestem Stand – das ist wichtig! Auch wenn bei Ihnen bereits der WSH installiert ist, sollten Sie trotzdem STE51DE.EXE installieren. Diese Datei enthält nämlich den neuesten WSH 2.0, der nicht nur um wesentliche Fehler bereinigt ist, sondern außerdem schneller läuft und viele neue Befehle mitbringt. Eine ausführliche Einführung in die generelle Scripterstellung und den Umgang mit dem Debugger finden Sie im Vorgängerband »Franzis: Professional Series Scripting Host Praxisbuch«.
1.1.2
Ein Script starten: das passiert hinter den Kulissen
Öffnen Sie nun Ihr Beispielscript! Wenn auf Ihrem System der Windows Scripting Host installiert ist, dann wird das Script gestartet und präsentiert in einem kleinen Dialogfenster seinen Namen. Öffnet sich dagegen nur der Editor und zeigt den Script-Text, dann ist der WSH bei Ihnen noch nicht installiert. Installieren Sie ihn so wie gerade beschrieben rasch nach. Sobald Sie (irgendeine) Datei öffnen, schaut sich Windows die Dateiextension an. Im Beispiel entdeckt es die Extension .VBS. Daraufhin schaut es in seiner internen Registrierungsdatenbank nach, was es mit solchen Dateien machen soll. Sie können ebenfalls nachschauen:
1.1
Der Scripting Host – so funktioniert er wirklich
29
1. Wählen Sie im Startmenü Ausführen und geben Sie ein: REGEDIT [Enter]. Der Registrierungseditor startet. 2. Doppelklicken Sie in der linken Spalte auf HKEY_CLASSES_ROOT, und suchen Sie den Unterschlüssel .vbs. Wenn der WSH installiert ist, finden Sie ihn und sehen in der rechten Spalte den Eintrag VBSFile. 3. Suchen Sie nun den Schlüssel, der so heißt wie der Begriff in der rechten Spalte, also den Schlüssel VBSFile. Jetzt sind Sie am Ziel. Der Unterschlüssel ScriptEngine legt zum Beispiel fest, welche »Sprache« in vbs-Scripts gesprochen wird, und über shell – open – command entdecken Sie auch gleich das Programm, mit dem vbs-Scripts hinter den Kulissen geöffnet werden: WSCRIPT.EXE – der Scripting Host.
Bild 1.3: In der Registry ist vermerkt, wer Ihre Scriptdateien ausführt
Windows findet also über seine Registry heraus, wer für vbs-Dateien zuständig ist, und verfüttert das Script anschließend an den Scripting Host, nämlich an das Programm WSCRIPT.EXE. Bevor ich Ihnen gleich zeige, wie der Scripting Host das Script eigentlich ganz genau verspeist, möchte ich den Scripting Host etwas aus seinem dunklen Versteck zerren. Sie können ihn nämlich auch direkt aufrufen, ganz ohne Script: 1. Wählen Sie im Startmenü Ausführen, und geben Sie ein: WSCRIPT.EXE [Enter]. 2. Schwupp, schon meldet er sich zu Wort: mit einem Dialogfenster. Darin legen Sie Grundeinstellungen fest, die für alle Scripts gelten. Wenn Sie wollen, können Sie zum Beispiel ein Timeout festlegen. Scripts, die länger als diese Zeit brauchen, werden kurzerhand abgebrochen. Wählen Sie diese Option nicht! Sie würde sonst für alle Scripts gelten, und später könnte es leicht passieren, daß umfangreiche Scripts nicht bis zu Ende ausgeführt werden. Besser ist, ein Timeout maßgeschneidert für das jeweilige Script festzulegen. Dazu klicken Sie Ihre Scriptdatei mit der rechten Maustaste an, wählen Eigenschaften und klicken auf das Register Script. Jetzt sehen Sie dieselben Einstellmöglichkeiten, die diesmal aber nur für dieses Script allein gelten – schon wesentlich besser.
30
Kapitel 1: Sprachschatz Ihrer Scripts erweitern
Bild 1.4: In diesem Dialog werden die generellen WSH-Eigenschaften definiert
Bild 1.5: Besser: Eigenschaften nur für ein bestimmtes Script setzen
Die allermeisten Feineinstellungen regelt der Scripting Host gar nicht in seinem Dialogfenster. Machen Sie das nächste Experiment: 1. Wählen Sie im Startmenü Ausführen, und geben Sie ein: WSCRIPT.EXE /? [Enter]. 2. Schon besser: der Scripting Host präsentiert nun all seine Geheimoptionen, und die können ausgesprochen nützlich werden. Mehr dazu in einem Moment.
1.1
1.1.3
Der Scripting Host – so funktioniert er wirklich
31
WSCRIPT.EXE oder CSCRIPT.EXE?
Den Scripting Host gibt es gleich zweimal: einmal als Windows-Programm und ein zweites Mal als DOS-Programm. Wobei das etwas gelogen ist: auch die DOS-Version des Scripting Host läuft nur unter Windows. Allerdings öffnet diese Version ein DOS-Fenster und macht es sich darin gemütlich. Wollen Sie ein Script testweise mit der DOS-Version ausführen? Dann klicken Sie Ihr Script mit der rechten Maustaste an und wählen anstelle von Öffnen den Befehl Mit Eingabeaufforderung öffnen. Sollen Scripts grundsätzlich mit CSCRIPT.EXE (und nicht wie in der Voreinstellung mit WSCRIPT.EXE) ausgeführt werden, dann verwenden Sie diesen Befehl: WSCRIPT.EXE //H:CScript [Enter]. Um wieder WSCRIPT.EXE zur Voreinstellung zu machen, verwenden Sie das Gegengift: WSCRIPT.EXE //H:WScript [Enter].
1.1.4
Internet Explorer als Script Host einsetzen
Gerade haben Sie entdeckt, daß einfache Scriptdateien vom Windows Scripting Host ausgeführt werden. Entweder WSCRIPT.EXE oder CSCRIPT.EXE liest Ihren Scriptcode und verfüttert ihn dann an Windows. Das ist die Voraussetzung, damit Ihr Script nützliche Dinge anstellen kann. Allerdings ist der Windows Scripting Host nicht der einzige Script Host. Es gibt viele weitere Programme, die Scriptcode lesen und ausführen können. Der Internet Explorer ist nur ein Beispiel. Er führt ebenso wie der Windows Scripting Host kreuzbrav Scripts aus, die Sie in Webseiten einbetten. Machen Sie dazu den folgenden Test: 1. Wählen Sie im Startmenü Ausführen, und geben Sie ein: NOTEPAD [Enter]. Der Texteditor startet. Nun geben Sie Ihr Script ein, das diesmal in ein rudimentäres HTML-Rahmenwerk eingebunden ist: <script language = "VBScript"> MsgBox "Hallo Welt!"
2. Speichern Sie diesen Code: Wählen Sie im Datei-Menü Speichern unter, stellen Sie oben in der Liste Speichern in ein: Desktop, und klicken Sie dann in die Zeile Dateiname. Speichern Sie Ihre Testdatei als SCRIPT.HTM [Enter]. Auf dem Desktop liegt nun eine Webseite. Die Dateiextension HTM hat aus dem einfachen Text eine HTML-Datei gemacht, und wenn Sie sie öffnen, dann startet der Internet Explorer – oder jeder andere Browser, der auf Ihrem System für HTML-Dateien zuständig ist. Allerdings wird Ihr Script nur dann ausgeführt, wenn Sie den Internet Explorer verwenden. Andere Browser unterstützen die Scriptsprache VBScript nicht und beschränken sich auf JavaScript. Verwenden Sie den Internet Explorer als Standardbrowser, dann erscheint tatsächlich ein Dialogfenster und begrüßt Sie.
32 1.1.5
Kapitel 1: Sprachschatz Ihrer Scripts erweitern
Die besonderen Funktionen des Script Hosts
Zusätzlich zu den normalen Scriptbefehlen, die in allen Script Hosts gleich sind, blendet der jeweils gewählte Script Host sich selbst als Objekt ein. Das klingt ungeheuer technisch, ist aber eigentlich ganz banal: Wenn Sie Ihr Script als VBS- oder JS-Datei im Windows Scripting Host ausführen, dann blendet der Windows Scripting Host unerkannt hinter den Kulissen sich selbst als WScript-Objekt ein. Über dieses Objekt bekommen Sie also Zugriff auf die persönlichen Befehle des Windows Scripting Hosts. Diese Befehle stehen Ihnen immer zur Verfügung, ganz gleich, welche Scriptsprache Sie im WSH einsetzen, und oben hatten Sie bereits gesehen, wie Sie WScript.ScriptFullName dazu einsetzen, den Namen der Scriptdatei herauszufinden. Führen Sie dagegen ein Script im Internet Explorer aus, dann gibt es kein WScript-Objekt. WScript.ScriptFullName ist also in einem Script, das eingebettet in einer Webseite abläuft, nicht vorhanden – und auch gar nicht sinnvoll. Schließlich gibt es in diesem Fall gar keine eigenständige Scriptdatei, deren Namen man verkünden könnte. Statt dessen blendet der Internet Explorer ein anderes Objekt ein: document. Es entspricht dem HTML-Dokument, in das Ihr Script eingebettet ist, und dieses Objekt bringt ähnlich wie WScript eine ganze Reihe persönlicher Funktionen mit. Wiederum stehen Ihnen diese Funktionen in allen Scripts Ihrer Webseite zur Verfügung, ganz gleich, ob Sie VBScript, JavaScript oder irgendeine andere Scriptsprache einsetzen. Probieren Sie zum Beispiel das folgende Beispiel aus: <script language = "VBScript"> MsgBox TypeName(document) document.write "Hello!" document.parentWindow.alert "Hello!"
Speichern Sie es im Texteditor als TEST2.HTM, und öffnen Sie dann die Datei! Diesmal passiert eine Menge mehr: Zuerst gibt Ihr Script den Objekttyp aus, der sich hinter document verbirgt: HTMLDocument. Anschließend verwendet das Script die write-Methode des document-Objekts, um einen Text ins Internet Explorer-Fenster auszugeben. Danach erfragt das Script via parentWindow das Fensterobjekt, in dem das HTML-Dokument angezeigt wird, und kann über die alert-Methode dieses Fensterobjektes ein Dialogfenster auf den Bildschirm zaubern. Sie könnten den Code auch etwas anders schreiben: <script language = "VBScript"> MsgBox TypeName(document) document.write "Hello!" set fenster = document.parentWindow
1.1
Der Scripting Host – so funktioniert er wirklich
33
fenster.alert "Hello!" MsgBox TypeName(fenster)
Speichern Sie die Datei als TEST3.HTM. Hier wird das Fensterobjekt zuerst in einer eigenen Variablen gespeichert: fenster. TypeName verrät Ihnen den offiziellen Namen des Fensterobjekts: HTMLWindow (oder bei moderneren Internet Explorern HTMLWindow2).
1.1.6
Objekte bereichern Ihren Script-Wortschatz
Eben haben Sie bereits gesehen, wie Sie den eingeschränkten Wortschatz Ihrer Scripts kräftig aufstocken können. Das Geheimnis sind Objekte. Dahinter verbergen sich »Black Boxes«, deren Innenleben Ihnen herzlich egal sein kann. Haben Sie erst einen Weg gefunden, auf ein Objekt zuzugreifen, dann stehen Ihren Scripts anschließend alle Funktionen zur Verfügung, die dieses Objekt anzubieten hat. Einige Objekte – wie WScript oder document – werden von Anfang an vom jeweiligen Script Host zur Verfügung gestellt. Andere Dokumente – wie HTMLWindow – werden von Objektfunktionen zurückgeliefert. parentWindow ist solch eine Funktion, und wenn Sie das Objekt unter einem eigenen Namen speichern wollen, dann verwenden Sie dazu wie im letzten Beispiel den Set-Befehl. Tip: Set – bei fremden Objekten ungeheuer wichtig! VBScript braucht den Set-Befehl nie, Sie hingegen schon! Set ist ungeheuer wichtig, wenn Sie mit Objekten arbeiten. Objekte sind nämlich keine normalen Variablen, sondern hinter Objekten steckt eine Referenz auf das Objekt. Deshalb dürfen solche Referenzen nur mit Set an eine Variable übergeben werden.
Die allermeisten Objekte allerdings dümpeln unbenutzt und unerkannt in den weiten Tiefen Ihres Windows-Systems umher. Solche Objekte sprechen Sie mit den VBScript-Befehlen CreateObject und GetObject an. Ein ganz besonders wichtiges Objekt heißt Scripting.FileSystemObject. Es stellt Ihnen alle nur denkbaren Befehle rund um Ihr Dateisystem zur Verfügung. Schauen Sie mal: ’ 1-1.vbs set filesystem = CreateObject("Scripting.FileSystemObject") ’ Auf einen Ordner zugreifen: set ordner = filesystem.GetFolder("C:\") ’ Alle Dateien auflisten liste = "" for each datei in ordner.files liste = liste & datei.name & ", " next ’ anzeigen MsgBox liste
34
Kapitel 1: Sprachschatz Ihrer Scripts erweitern
Hier verschafft sich das Script zuerst mit CreateObject Zugriff auf das Scripting.FileSystemObject und speichert mit Hilfe von Set eine Referenz darauf in der Variablen filesystem. Danach kann es alle Befehle einsetzen, die dieses Objekt zu bieten hat. Zuerst verwendet das Script GetFolders und läßt sich ein Ordnerobjekt zurückliefern. Es wird mit Set der Variablen ordner zugewiesen. Danach kann eine Schleife alle Dateien heraussuchen, die in diesem Ordner gelagert werden. Dazu verwendet die Schleife die Funktion files des Ordner-Objekts. Das Resultat: ein Dialogfenster listet fein säuberlich alle Dateinamen auf. Prima. Es kann höchstens sein, daß das Dialogfenster nicht groß genug ist, um wirklich alle Dateinamen anzuzeigen, aber das ist momentan verschmerzbar. Sicher wird sich spätestens jetzt eine zweifelnde Frage einschleichen: Wo um alles in der Welt erfährt man die nötigen Details über Objekte und ihre Funktionen? Wer verrät, welche Funktionen in Scripting.FileSystemObject schlummern und wie man sie einsetzt? Keine Sorge, diese Frage beantwortet sich in einem Moment ganz von selbst! Zuerst muß sich der Bogen schließen: Was passiert, wenn man das Scripting.FileSystemObject nicht im WSH verwendet, sondern zum Beispiel in einem eingebetteten Script im Internet Explorer? Ausprobieren: <script language = "VBScript"> set fs = CreateObject("Scripting.FileSystemObject") ’ Auf einen Ordner zugreifen: set ordner = fs.GetFolder("C:\") ’ Alle Dateien auflisten liste = "" for each datei in ordner.files liste = liste & datei.name & ", " next ’ anzeigen MsgBox liste
Wenn Sie diesen Code als TEST4.HTM speichern und dann die HTML-Datei öffnen, dann können vier Dinge passieren:
Es öffnet sich kein Internet Explorer, sondern ein anderer Browser. Sonst passiert nichts. Das ist normal, nur der Internet Explorer versteht VBScript. Für andere Browser ist das Script unsichtbar und müßte in JavaScript geschrieben sein.
Es öffnet sich der Internet Explorer, aber sonst passiert gar nichts. In diesem Fall verbieten die Sicherheitseinstellungen, daß »unsichere« ActiveX-Komponenten ausgeführt werden.
1.2
Internet Explorer als sinnvoller Script Host
35
Der Internet Explorer öffnet ein Dialogfenster und fragt nach, ob »potentiell unsichere ActiveX-Komponenten« gestartet werden sollen. Wenn Sie auf Ja klicken, wird das Script ausgeführt und listet die Dateinamen auf.
Der Internet Explorer öffnet sich und führt Ihr Script sofort aus.
Bild 1.6: Der Internet Explorer führt Scripts unter Umständen nicht sofort aus
Was sind »unsichere« ActiveX-Komponenten? Jedes Objekt, das Ihr Script via CreateObject oder GetObject öffnet, ist eine ActiveX-Komponente. Enthält dieses Objekt Befehle, die gefährlich sein könnten, dann gilt es als »unsicher«. Das Scripting.FileSystemObject-Objekt zum Beispiel ist potentiell gefährlich: Es lassen sich damit nicht nur Inhalte auf Ihrer Festplatte auskundschaften. Über den Delete-Befehl könnten damit sogar Dateien gelöscht werden. Damit gilt dieses Objekt zu Recht als »möglicherweise unsicher« – solch ein Objekt sollte auf keinen Fall als Teil einer Webseite gestartet werden können, denn sonst wären all Ihre Daten in Gefahr.
1.2
Internet Explorer als sinnvoller Script Host
Der Internet Explorer kann nur dann als sicherer Script Host verwendet werden, wenn einerseits sichergestellt ist, daß Sie sich beim Surfen im Internet keine gefährlichen ActiveX-Komponenten einfangen, andererseits aber lokale HTML-Dateien auf Ihrem System ohne Hemmnisse und Einschränkungen ausgeführt werden. Wie geht so was? Die Sicherheitseinstellungen des Internet Explorers sind die Lösung. Für alle »Außenbereiche« muß die Ausführung von potentiell gefährlichen Scripts streng verboten sein. Für HTML-Dateien, die Sie von Ihrer lokalen Festplatte aus öffnen, sollen dagegen alle Scriptbefehle aktiviert sein. Leider versteckt der Internet Explorer die wichtigen Sicherheitseinstellungen für die lokalen HTML-Dateien in seinem Dialogfenster. Lernen Sie deshalb gleich bei dieser Gelegenheit die »Macht« Ihrer Scripts kennen. Das nächste Script ist Ihr universeller Internet Explorer Generalschlüssel. Dieses Script schaltet auf Wunsch lokale Scripts frei und verbietet gleichzeitig in allen »externen« Zonen – wie zum Beispiel dem Internet – die Ausführung potentiell gefährlicher ActiveX-Komponenten. Damit sichern Sie Ihren Internet Explorer gegen viele Internet-Gefahren und gewinnen gleichzeitig einen neuen Scripting Host hinzu.
36
Kapitel 1: Sprachschatz Ihrer Scripts erweitern
’ 1-2.vbs ' die nötigen Funktionen für den Registry-Zugriff bekommen ' WScript.Shell stellt sie zur Verfügung set wshshell = CreateObject("WScript.Shell") ' Hier lagern die Sicherheitseinstellungen des Internet Explorers key1 = "HKEY_CURRENT_USER\Software\Microsoft\Windows" _ & "\CurrentVersion\Internet Settings\Zones\" ' dieser Eintrag ist für potentiell unsichere ' ActiveX Komponenten zuständig key2 = "\1201" ' ActiveX-Komponenten in den Zonen 1 bis 5 verbieten for x = 1 to 5 wshshell.RegWrite key1 & x & key2, 2, "REG_DWORD" next ' ActiveX-Komponenten in der Zone 0 (lokale Dateien) wahlweise ' nur auf Nachfrage oder sofort ausführen curstat = wshshell.RegRead(key1 & "0" & key2) select case curstat case 1: status = "Bei ActiveX Objekten wird nachgefragt." _ & " Wollen Sie Objekte direkt ausführen lassen?" action = 0 case 2: status = "ActiveX Objekte werden nicht ausgeführt." _ & " Wollen Sie Objekte direkt ausführen lassen?" action = 0 case 0: status = "ActiveX Objekte werden ausgeführt. " _ & "Wollen Sie lieber nachfragen lassen?" action = 1 case else: MsgBox "Unbekannte Einstellung." WScript.Quit end select ' Nachfragen, was gewünscht ist: answer = MsgBox(status, vbYesNo+vbQuestion) if answer = vbYes then wshshell.RegWrite key1 & "0" & key2, action, "REG_DWORD" MsgBox "Einstellungen geändert!", vbInformation end if
Tip: Internet Explorer als »Hilfs-Scripting-Host«! Natürlich brauchen Sie das obige Script nicht unbedingt. Sie können auch von Hand den Registrierungseditor REGEDIT.EXE öffnen und dann im angegebenen Schlüssel die Veränderungen manuell eintragen. HKCU steht dabei für HKEY_CURRENT_USER. Das kann praktisch sein: Vielleicht wollen Sie Scripts auf zahlreichen Rechnern im Netzwerk einsetzen, haben aber keine Lust, dort überall den WSH zu installieren. Sofern mindestens der IE4 auf den Computern installiert ist und sofern Sie die Registry-Änderungen von oben auf diesen Rechnern durchführen, kann also auch der Internet Explorer als sofort einsetzbarer Windows Script Host verwendet werden.
1.2
1.2.1
Internet Explorer als sinnvoller Script Host
37
Internet Explorer als unsichtbarer Script Host
Damit der Internet Explorer als vernünftiger Script Host eingesetzt werden kann, muß ein Weg gefunden werden, um das Internet Explorer-Fenster zu verstecken. Schließlich ist es wenig elegant, wenn ständig ein leeres IE-Fenster Ihre Scriptaktionen begleitet. Mit dem folgenden Rahmenwerk können Sie jedes beliebige VBScript-Script vom Internet Explorer ausführen lassen, ohne daß sein Fenster dabei störend zutage tritt. Speichern Sie es als TEST5.HTM. <script language = "VBScript"> document.parentWindow.resizeTo 0,0 ’ ...hier folgt der Scriptcode MsgBox "Script läuft ohne IE-Fenster!" ' ...hier könnte weiterer Scriptcode stehen
Eingebettet in dieses Rahmenwerk führt Ihr Internet Explorer nun jedes beliebige VBScript-Script aus, ohne daß auf dem Computer der Windows Scripting Host installiert zu sein braucht. Es geht also auch ohne. Allerdings sollten Sie beachten, daß der WSH als Teil seiner Installation eine Reihe von zusätzlichen Komponenten mitinstalliert. Das Scripting.FileSystemObject gehört zum Beispiel dazu, und so kann es durchaus sein, daß auf einem WSH-losen System zwar der Internet Explorer einwandfrei Ihre Scripts ausführt, aber wichtige Zusatzobjekte fehlen. Tip: Scripting.FileSystemObject – wo kommt es eigentlich her? Schauen Sie sich das Problem stellvertretend am wichtigen Scripting.FileSystemObject an: nur mit diesem Objekt ist es möglich, per Script das Dateisystem zu verwenden. Der WSH bringt das Objekt mit, aber der ist nicht der einzige: Wenn Sie auf dem Computer den Internet Information Server oder den Personal Web Server installieren, wird ebenfalls das Scripting.FileSystemObject installiert. Sie können das Objekt sogar separat installieren – völlig losgelöst vom WSH. Dazu kopieren Sie die Datei SCRRUN.DLL in den Windows-Systemordner und registrieren die Datei: Im Startmenü wählen Sie Ausführen und geben ein: REGSVR32.EXE SCRRUN.DLL [Enter].
1.2.2
Streng geheim: HTA-Dateien des Internet Explorer 5
Das Malheur mit Sicherheitsbeschränkungen und lokalen Scripts hat Microsoft natürlich erkannt und reagiert. Bei Windows 2000 können Sie deshalb ab sofort Webseiten als universelle Bedienflächen für Ihre Scripts einsetzen, ohne daß Sie sich um die ActiveX-Sicherheitseinstellungen zu kümmern brauchen. Das Geheimnis sind HTA-Dateien. Solche Dateien werden im IE 5 geöffnet, und die meisten Scripting-Objekte stehen in HTA-Dateien unabhängig von den Sicherheitseinstellungen zur Verfügung. Das ist möglich, weil HTA-Dateien nur
38
Kapitel 1: Sprachschatz Ihrer Scripts erweitern
lokal ausführbar sind, nicht über das Web. Zugleich spart sich das Internet Explorer-Fenster seine üblichen Symbolleisten und Menüs und konzentriert sich nur auf die Darstellung Ihrer Scripts. Allerdings sind nur solche Befehle erlaubt, die im IE-Fenster ablaufen. Der MsgBox-Befehl ist tabu, und deshalb müßten Sie das vorangegangene Beispielscript nur etwas umwandeln. Speichern Sie es als TEST6.HTA. <script language = "VBScript"> set fs = CreateObject("Scripting.FileSystemObject") ’ Auf einen Ordner zugreifen: set ordner = fs.GetFolder("C:\") ’ Alle Dateien auflisten liste = "" for each datei in ordner.files liste = liste & datei.name & ", " next ’ anzeigen MsgBox liste
Denken Sie bitte daran: HTA-Dateien funktionieren nur bei Windows 2000. HTA-Dateien besitzen kein eigenes Icon und werden deshalb immer mit dem Windows-Standard-Icon für unbekannte Dateien ausgerüstet.
Bild 1.7: Webseiten mit HTA-Extension werden als lokale Management Console geöffnet
1.3
1.3
Scripts um zusätzliche Funktionen bereichern
39
Scripts um zusätzliche Funktionen bereichern
Eins ist klar: In diesem Buch geht es nicht um die reine Scripterstellung. Wie Sie VBScript verwenden und damit nützliche Scripts schreiben, habe ich bereits in meinem ersten Buch zum Windows Scripting Host in allen Details beschrieben: Franzis Professional Series Windows Scripting Host Praxisbuch. In diesem Buch geht es darum, wie Sie Ihren Scripts neue und bessere Befehle beibringen. Befehle, mit denen Sie zum Beispiel Windows NT/2000 Benutzerkonten verwalten, CD-Schubladen ausfahren oder fremde Programme fernsteuern. Jede Scripterweiterung geht dabei denselben Weg: über CreateObject oder GetObject greift Ihr Script auf zusätzliche Objekte zu, die die nötigen neuen Funktionen zur Verfügung stellen. Doch gibt es ganz unterschiedliche Wege, an Objekte heranzukommen:
Im Kapitel 2 lernen Sie ein wertvolles Tool kennen, das ich für Sie programmiert habe und das Sie auf der Buch-CD finden. Dieses Tool analysiert vollautomatisch Ihr System und verrät, welche Objekte es eigentlich auf Ihrem System gibt, wie ihr Innenleben aussieht und welche Funktionen und Befehle darin schlummern. Dieses Spionage-Tool schreibt Ihnen auf Wunsch sogar das komplette Grundgerüst für Ihre Scripts. Allein mit diesem Tool und dem Wissen, das es bereitstellt, gewinnen Sie Hunderte neuer Funktionen hinzu.
Im Kapitel 3 verrate ich Ihnen, wann GetObject sinnvoll eingesetzt wird. Ich zeige Ihnen, wie Sie sich per GetObject ins ADSI (Active Directory Service Interface) einklinken und so Windows NT/2000-Benutzerkonten verwalten, Ordner im Netzwerk freigeben und BetriebssystemDienste starten und beenden.
Im Kapitel 4 stelle ich Ihnen die kostenlose Visual Basic Control Creation Edition vor. Sie erlaubt Ihnen, ganz eigene Objekte zu schreiben. Das ist weit weniger schwierig, als Sie glauben, und mit der VB CCE stehen Ihren Scripts plötzlich Tausende neuer Funktionen zur Verfügung.
41
2
Mit dem Scripting Spy geheime Systemobjekte ausspionieren
Auf Ihrem System schlummern Hunderte von ActiveX-Objekten mit Tausenden von nützlichen Funktionen, nur verrät Ihnen das niemand! All diese Funktionen könnten Sie sofort und ohne weitere Kosten in eigenen Scripts einsetzen. Wenn Sie wüßten, wo diese verborgenen Objekte schlummern, wie sie angesprochen werden und welche Funktionen darin versteckt sind. Rätseln Sie nicht länger! Ich habe für Sie ein universelles Spionagetool entwickelt. Es befindet sich auf der Buch-CD und braucht nur noch installiert zu werden. Dieses Spionagetool verrät Ihnen alles, was Sie wissen müssen, um auch die verstecktesten Systemfunktionen in Ihren Scripts zu nutzen. Lernen Sie auf den nächsten Seiten die verblüffenden Möglichkeiten des Scripting Spy genau kennen! Ganz nebenbei werden Sie dabei nicht nur eine interessante Reise durch Ihr System machen, sondern sehr viel »Expertenwissen« über COM-Objekte hinzugewinnen. Und zwar gänzlich schmerzfrei, denn der Scripting Spy enthüllt den Aufbau von COM-Objekten und macht das Innenleben wie mit einem Röntgen-Apparat sichtbar und transparent. Wer sofort loslegen will, kann natürlich auch gleich zu Kapitel 2 springen. Clever ist das aber nicht, denn nur mit den Infos der folgenden Seiten behalten Sie den Überblick und können alles souverän meistern.
2.1
Scripting Spy – das müssen Sie wissen
Der Scripting Spy ist eine kostenlose Beigabe zu diesem Buch, und einem geschenkten Gaul schaut man nicht ins Maul. So oder ähnlich könnte man die Sache formulieren, denn der Scripting Spy ist mein persönliches Objekt-Röntgen-Gerät, mit dem ich zahlreiche Geheimnisse in diesem Buch enträtseln konnte. Dieses Tool ist in einer Rotwein-reichen Woche in der Provence entstanden und war nie für den kommerziellen Markt bestimmt. Ich kann deshalb keinerlei Garantien über die Funktionstüchtigkeit dieses Tools geben. Trotzdem bin ich für jegliches Feedback an
[email protected] dankbar und verspreche natürlich, das Tool weiterzuentwickeln. Der kritischste Moment ist der Programmstart selbst: Hier analysiert der Scripting Spy alle Objekte auf Ihrem Computer, und das funktioniert auch in aller Regel wunderbar. Dumm nur, wenn in Ihrer Registry Inkonsistenzen entdeckt werden: Der Scripting Spy kann sich bei unlogischen RegistrySchlüsseln durchaus verabschieden, weil mir die Zeit fehlte, jedwede Fehlerbedingung abzufangen.
42
Kapitel 2: Mit dem Scripting Spy geheime Systemobjekte ausspionieren
Falls Sie übrigens ein Hardcore-C-Programmierer sind und zufällig mit dem Gedanken spielen, das Tool zusammen mir mir zu perfektionieren, dann melden Sie sich bitte.
2.1.1
Scripting Spy installieren
Um Ihr Spionagetool zu installieren, starten Sie auf der Buch-CD im Verzeichnis SCRIPTING SPY das Programm SETUP.EXE. Klicken Sie dann auf OK und anschließend auf die große Schaltfläche mit dem Installations-Symbol. Das Programm wird installiert, und Sie finden den Scripting Spy anschließend in Ihrem Programme-Menü. Tip: Probleme bei der Installation? Sollte die Installation nicht klappen, dann sind dafür vermutlich Versionskonflikte verantwortlich – das alte Windows-Problem, auch »DLL HELL« genannt. Kontrollieren Sie, ob im Software-Modul der Systemsteuerung möglicherweise schon ein früher installierter Scripting Spy gemeldet wird, und deinstallieren Sie ihn dort. Hilft alles nichts, dann mailen Sie mir:
[email protected].
2.1.2
Nachschauen, welche Objekte es auf Ihrem System gibt
Starten Sie den Scripting Spy in Ihrem Programme-Menü. Ein Dialogfenster erscheint und bittet um etwas Geduld, während das Tool Ihr System unter die Lupe nimmt. Dies ist der kritischste Moment, weil hierbei die Registry untersucht wird. Fehleinträge in der Registry können den Scripting Spy verwirren und zur Aufgabe zwingen. Wie lange der Suchprozeß dauert, hängt von zwei Dingen ab: der Geschwindigkeit Ihres Rechners und natürlich der Anzahl der Programme, die auf Ihrem Computer installiert sind.
Bild 2.1: Der Scripting Spy untersucht automatisch Ihr gesamtes System
2.1
Scripting Spy – das müssen Sie wissen
43
Tip: Scripting Spy benötigt den Scripting Host! Weil der Scripting Spy ein Tool für die Scriptprogrammierung ist, muß der WSH auf Ihrem System installiert sein. Andernfalls quittiert der Scripting Spy den Dienst. Wie Sie den WSH blitzschnell auf Ihrem System installieren, wenn er noch fehlt, lesen Sie in Kapitel 1 – oder Sie sparen sich das Blättern und installieren die Datei STE51DE.EXE von der Buch-CD.
Anschließend können Sie per Klick auf Info die Version Ihres WSH kontrollieren und mit Akzeptiert die Spionagearbeit aufnehmen:
Bild 2.2: Der Scripting Spy meldet Version des Scripting Host und der Sprach-Engines
Im Register Modul aussuchen sehen Sie eine lange Liste mit Namen. Vielleicht kommen Ihnen diese Namen bekannt vor (siehe Bild 2.3). In der Voreinstellung listet der Scripting Spy alle Programm-IDs auf, die sogenannten ProgIDs. Die kennen Sie schon, denn die ProgIDs sind die offiziellen Namen der Objekte. Mit diesen ProgID-Namen locken Sie Objekte hervor und können sie anschließend in eigenen Scripts nutzen. Die Liste zeigt allerdings der Übersicht wegen nicht sofort die ganze ProgID. Weil ProgIDs immer aus zwei Teilen bestehen, die durch einen Punkt getrennt sind, zeigt die Liste zuerst nur den ersten Teil. Doppelklicken Sie auf solch einen Eintrag, dann sehen Sie in den Untereinträgen alle ProgIDs, die den ersten Teil im Namen gemeinsam teilen. Probieren Sie’s einfach aus: Oben hatten Sie bereits das Scripting.FileSystemObject kennengelernt, mit dessen Hilfe Sie das gesamte Dateisystem im Griff haben. Suchen Sie in der Liste nach dem Begriff Scripting, und doppelklicken Sie dann darauf! Drei Untereinträge erscheinen: • Scripting.Dictionary • Scripting.FileSystemObject • Scripting.Encoder
44
Kapitel 2: Mit dem Scripting Spy geheime Systemobjekte ausspionieren
Sie sehen also auf einen Blick: Das Scripting-Modul enthält gleich drei Objekte, und das Scripting.FileSystemObject Objekt ist nur eins davon.
Bild 2.3: Aha, der Scripting Spy listet alle Objekte auf, die es bei Ihnen gibt!
Der Scripting Spy kann aber noch viel mehr Infos liefern. Klicken Sie auf das Register Beschreibung, dann listet der Scripting Spy die Objekte geordnet nach ihrer Beschreibung. Das Scripting.FileSystemObject würden Sie nun unter dem Eintrag FileSystem Object finden.
Bild 2.4: Auf Wunsch auch anders: COM-Objekte nach Hersteller sortiert
2.1
Scripting Spy – das müssen Sie wissen
45
Die Beschreibung-Ansicht ist vor allem dann wichtig, wenn Sie selbst auf die Pirsch gehen möchten und nicht genau wissen, wo sich Nachschauen lohnt. Die Beschreibung Steuerelement für Kodak-Bildbearbeitung ist einfach aussagekräftiger als die ProgID, die dahinter steckt: imaging.editctrl. Wollen Sie die Objekte dagegen nach Herkunft sortieren, dann klicken Sie auf das Register Hersteller. Jetzt sehen Sie alle Hersteller, die ActiveX-Objekte auf Ihrem Computer installiert haben. Der Eintrag »n/a« faßt alle Objekte zusammen, bei denen kein Hersteller angegeben ist.
2.1.3
Detailinformationen zu einem Objekt sehen
Ganz gleich, ob Sie sich für die Ansicht ProgID, Beschreibung oder Hersteller entschieden haben: Sobald Sie einen Oberbegriff der Liste per Doppelklick öffnen und dann einen Untereintrag anklicken, sehen Sie rechts alle wichtigen Detailinformationen zu diesem Objekt. Wählen Sie zum Beispiel das Register ProgID, und suchen Sie den Eintrag Scripting. Doppelklicken Sie darauf, und klicken Sie auf den Untereintrag Scripting.FileSystemObject. Rechts sehen Sie nun Detailinformationen über das Objekt. Sie sehen zum Beispiel, daß dieses Objekt ein »In-Process Server« ist und in der Datei SCRRUN.DLL lebt. Tip: In-Process und Out-of-Process – das steckt dahinter... Die meisten ActiveX-Objekte sind In-Process-Objekte. In-Process heißt: das Objekt kann nicht als eigenständiges Programm laufen, sondern muß in den Adreßraum eines anderen Programms eingeklinkt werden. Greift Ihr Script auf ein In-Process-Objekt zu, dann klinkt sich das Objekt in den Adreßraum des Script Hosts ein. Für Sie hat das alles nur eine praktische Konsequenz: auf In-Process-Objekte muß Ihr Script warten. Solange das In-Process-Objekt eine Aufgabe erledigt, ist die weitere Script-Abarbeitung angehalten. Bei Out-of-Process-Objekten kann Ihr Script dagegen weiterarbeiten, während das Objekt seine Arbeit erledigt.
2.1.4
Wichtige Objekte in die Favoritenliste übernehmen
Sehr viele ActiveX-Objekte, die der Scripting Spy auflistet, sind entweder nur für interne Zwecke gedacht oder interessieren Sie schlichtweg nicht. Damit Sie sich nicht immer wieder durch die lange Gesamtliste klicken müssen, können Sie interessante Objekte in Ihre persönliche Hit-Liste übernehmen. Suchen Sie einfach ein Objekt heraus, das Sie interessiert. Das wichtige Scripting.FileSystemObject sollte zum Beispiel dazugehören. Tip: So klappt’s am besten Am besten picken Sie sich für den Anfang genau ein interessantes Objekt heraus, zum Beispiel Scripting.FileSystemObject, und fügen es zu Ihren Favoriten hinzu. Anschließend erforschen Sie dieses Objekt so wie unten beschrieben. Haben Sie es anschließend genauestens kennengelernt, dann können Sie optimal entscheiden, ob es weiterhin als nützliches Objekt in der Favoritenliste bleiben soll oder lieber wieder herausfliegt.
46
Kapitel 2: Mit dem Scripting Spy geheime Systemobjekte ausspionieren
Anschließend knöpfen Sie sich das nächste unbekannte Objekt aus der Gesamtliste vor und machen weiter, bis Sie entweder keine Lust mehr oder alle Objekte analysiert haben. In Ihrer Favoritenliste finden Sie dann stets alle wichtigen Objekte, die Ihren Scripts nützliche Zusatzfunktionen bescheren.
In der rechten Spalte klicken Sie dann auf die Schaltfläche Scripting.FileSystemObject zu Favoriten hinzufügen. Mit derselben Schaltfläche entfernen Sie das Objekt auch wieder aus der Liste. Sobald Sie mindestens ein Objekt zum »Favoriten« erklärt haben, wacht die Option »nur Favoriten« auf. Wählen Sie diese Option, dann schrumpft die Objektliste und zeigt nur noch die von Ihnen handverlesenen Objekte an – praktisch!
2.1.5
Potentiell nutzlose Objekte aus der Liste verbannen
Auf Ihrem System können Hunderte von ActiveX-Objekten installiert sein. Welche sind interessant für einen Scripter? Natürlich könnten Sie alle Objekte der Reihe nach untersuchen, aber das wäre ein zeitraubendes Unterfangen. Deshalb hilft Ihnen der Scripting Spy auf Wunsch! Wählen Sie die Option vorselektiert, dann entfernt der Scripting Spy alle Objekte aus der Liste, die vermutlich keine interessanten Script-Befehle enthalten. Aber auch in der Gesamtliste (Option alle zeigen) bekommen Sie Hinweise: Symbol
Bedeutung Interessantes Objekt, enthält mindestens eine Funktion Vermutlich uninteressant: enthält keine Funktionen, nur Informationen und Subs Dieses Objekt wurde zu den Favoriten hinzugefügt Vorsicht: keine TypeLibrary für dieses Objekt gefunden. Wenn Sie es trotzdem auswählen, sucht der Scripting Spy ausführlicher nach einer TypeLibrary, kann aber nicht garantieren, daß es wirklich eine gibt
Tab. 2.1: Info-Symbole zeigen, wie interessant ein unbekanntes COM-Objekt ist
2.2
Röntgen-Schirm: Welche Funktionen schlummern in den Objekten?
Die Namen der auf Ihrem System versammelten Objekte kennen Sie jetzt. Nur nützen Ihnen die natürlich herzlich wenig, wenn Sie nicht auch wissen, welche Funktionen darin überhaupt zur Verfügung gestellt werden. Deshalb hat der Scripting Spy einen eingebauten Röntgenschirm, der auf Wunsch jedes Objekt genau durchleuchtet und alle geheimen Informationen preisgibt. Suchen Sie sich dazu auf dem Register Modul aussuchen zuerst das Objekt heraus, in das Sie hineinschauen wollen. Wählen Sie zum Beispiel das Scripting.FileSystemObject. Anschließend klicken Sie unten auf die Schaltfläche Details oder doppelklicken auf den Eintrag.
2.2
Röntgen-Schirm: Welche Funktionen schlummern in den Objekten?
47
Schwupp, sofort analysiert der Scripting Spy das ausgewählte Objekt und schaltet um auf das Register Röntgen. Ganz oben finden Sie ein Textfeld namens Typelib Datei. Es enthält den Namen der Type Library, die für dieses Objekt zuständig ist. Darunter listet der Scripting Spy alle Einzelteile auf, die es im Objekt finden konnte. Außerdem markiert er automatisch die »Klasse«, die für das ausgewählte Objekt zuständig ist. Im Falle des Scripting.FileSystemObject wird also die Klasse FileSystemObject aufgeklappt und darin das Interface IFileSystem3 markiert. In der Liste rechts daneben verrät der Scripting Spy, wie Ihr Script an das markierte Interface herankommt. Ganz korrekt meldet es in diesem Beispiel, IFileSystem3 sei direkt durch Scripting.FileSystemObject ansprechbar. Stimmt.
Bild 2.5: Röntgenschirm: Liefert automatisch die Geheiminfos aus unbekannten Objekten
In der Liste darunter schließlich sehen Sie alle Funktionen und Befehle, die Ihnen über Scripting.FileSystemObject zur Verfügung stehen. Heureka!
2.2.1
Wie COM-Objekte aufgebaut sind
Eigentlich brauchen Sie sich keine grauen Haare wachsen zu lassen, denn wenn Sie keine Lust auf technische Details haben, dann ignorieren Sie diesen Abschnitt einfach höflich. Der Scripting Spy stellt Ihnen auch ohne dieses Detailwissen zuvorkommend die Funktionen und Befehle unbekannter Objekte zur Verfügung.
48
Kapitel 2: Mit dem Scripting Spy geheime Systemobjekte ausspionieren
Allerdings ist es höchst spannend und interessant, sich den internen Aufbau von COM-Objekten näher anzusehen. Das Wissen, das Sie hier gewinnen, hilft Ihnen sehr dabei, die Zusammenhänge optimal zu verstehen. Schauen Sie sich dazu noch einmal die Liste oben links an: noch ist hier wahrscheinlich das IFileSystem3-Objekt markiert. Scrollen Sie testweise durch die Liste, und schauen Sie sich an, was sonst noch darin zu sehen ist. Jedes COM-Objekt enthält sogenannte CoClasses. Das sind eigenständige Objekte, die bestimmte Befehle anbieten. Die Liste zeigt Ihnen alle CoClasses, also alle Objekte, die in der betreffenden ActiveX-Komponente enthalten sind. Wie Sie von oben wissen, wohnt das Scripting.FileSystemObject in der Datei SCRRUN.DLL. Diese Datei enthält sehr viel mehr Intelligenz als nur das Scripting.FileSystemObject. Fünf CoClasses meldet Ihnen der Scripting Spy. Alle CoClasses, die über ProgIDs direkt von Ihren Scripts aus ansprechbar sind, werden mit diesem Symbol markiert: . Alle CoClasses, an die Ihr Script nicht direkt herankommt, erhalten dieses Symbol: . Klicken Sie in der Liste nacheinander auf die verschiedenen CoClasses! Im Feld rechts daneben sehen Sie sofort, wie Ihr Script an dieses Objekt herankommt: CoClass
So kommen Sie heran:
Dictionary Encoder Files FileSystemObject Folders
Scripting.Dictionary Scripting.Encoder Files in Modul Folder Scripting.FileSystemObject Subfolders in Modul Folder
Tab. 2.2: Die CoClasses des Scripting.FileSystemObject
Aha! Die Befehle des FileSystemObject können Sie also direkt über CreateObject (»Scripting.FileSystemObject«) ansprechen! An ein Files-Objekt kommen Sie dagegen nicht direkt heran. Trotzdem geht es, denn der Scripting Host kennt die internen Zusammenhänge: Der Befehl Files aus dem Modul Folder liefert Ihnen ein Files-Objekt! Nur: Wo bekommt man ein Folder-Modul her? Dazu gleich mehr, denn für solch knifflige Fragen hat der Scripting Spy eine eingebaute Automatik. Alle CoClasses enthalten sogenannte Standard-Interfaces. Das bedeutet bloß, das die CoClass intern aus weiteren Einzelteilen besteht. Doppelklicken Sie zum Beispiel auf die CoClass FileSystemObject: Sofort sehen Sie, daß das Standard-Interface IFileSystem3 heißt. Das Standard-Interface wird mit diesem Symbol markiert: . Einige CoClasses enthalten zusätzlich ein Event-Interface. Mehr zu Events lesen Sie in Kapitel 3.4. Event-Interfaces werden mit diesem Symbol markiert: . Möchten Sie noch tiefer in die Materie einsteigen, dann doppelklicken Sie auf das Standardinterface, also zum Beispiel auf IFileSystem3. Jetzt sehen Sie zwei weitere Unterpunkte: Input und Output.
2.2
Röntgen-Schirm: Welche Funktionen schlummern in den Objekten?
49
Input listet alle Zusatzinfos auf, die Sie kennen müssen, wenn Sie die Funktionen und Befehle dieses Interface aufrufen wollen. Doppelklicken Sie auf Input! Nun sehen Sie zum Beispiel den Eintrag SpecialFolderConst, und wenn Sie darauf klicken, sehen Sie unten die besonderen Konstanten, mit denen das FileSystemObject spezielle Ordner bezeichnet. Output listet übersichtlich alle Objekte auf, die Sie von den Funktionen dieses Interface zurückgeliefert bekommen können. Input und Output können Sie für den Augenblick getrost ignorieren. Diese Informationen werden später aber wichtige Hilfestellung leisten. Nicht umsonst organisiert der Scripting Spy die Liste der CoClasses und Interfaces baumartig. Weil der Scripting Host automatisch die Verwandtschaftsbeziehungen der einzelnen Module berücksichtigt, sehen Sie sofort, daß IFileSystem3 das Standardinterface von FileSystemObject ist, die beiden also zusammengehören. Ohne diese Zuordnung wäre es wesentlich schwieriger, die vielen einzelnen Objekte vernünftig zuzuordnen. Dennoch können Sie auch eine »flache« Ansicht auf den Inhalt der ActiveX-Komponente bekommen. Dazu öffnen Sie den Eintrag TypeLib, der mit diesem Symbol markiert ist: .
Bild 2.6: Wichtig: der Scripting Host verrät die Zahlenwerte interner Konstanten
Nun sehen Sie – nach Kategorien sortiert – die Einzelteile des ActiveX-Objekts: Kategorie
Beschreibung
Alias
Entspricht eigentlich einem anderen Objekt und sorgt dafür, daß dieses andere Objekt unter einem anderen (und meist freundlicheren) Namen angesprochen werden kann. Funktioniert also sozusagen wie eine Verknüpfung. Aufzählung; enthält meist Konstanten und Zusatzinformationen Die »Klassen«, also die Objekte, die im ActiveX-Modul schlummern Interface einer Klasse
Enum CoClass DispInterface
50
Kapitel 2: Mit dem Scripting Spy geheime Systemobjekte ausspionieren
Kategorie
Beschreibung
Interface Record Union
Interface einer Klasse Zusatzinformation; zum Beispiel benutzerdefinierte Variablentypen Bei Visual Basic nicht verwendet
Tab. 2.3: Die Klassen einer TypeLibrary
Tip: Konstanten – hier stehen die Werte! Ganz besonders wichtig ist der Eintrag Enum! Darin finden Sie alle Konstanten und deren Werte. Das ist enorm nützlich, denn viele Befehle erwarten bestimmte Zahlenwerte, und die Informationen aus Enum verraten Ihnen, welche Zahlenwerte richtig sind.
2.3
Nach Informationen suchen
Der Scripting Spy enthält eine komfortable Suchfunktion, die Ihnen wertvolle Dienste leistet, wenn Sie bestimmte Informationen dringend benötigen oder auf der Pirsch nach Funktionen sind, die Sie für ein Projekt gebrauchen könnten. Alle Suchfunktionen erreichen Sie über das Register Suchen.
2.3.1
Wo soll gesucht werden?
Jede Suche besteht aus drei Schritten. Im ersten Schritt legen Sie fest, wo gesucht werden soll: Wo suchen?
Beschreibung
Aktuelles Objekt
Wenn Sie sich bereits ein Objekt herausgepickt und mit dem Röntgenschirm untersucht haben, dann sucht der Scripting Spy in diesem Objekt. Das ist ideal, wenn Sie sich mit einem einzelnen Objekt beschäftigen und zum Beispiel nach Objekten, Befehlen oder Konstanten suchen. Haben Sie bereits Objekte in Ihre Favoritenliste eingefügt, dann sucht diese Option in allen Favoriten-Objekten. Das ist ideal, um Informationen zu finden, von denen Sie nicht genau wissen, welches Objekt sie eigentlich bereitstellt. Suchen Sie so zum Beispiel nach Befehlen, die Sie nachschlagen wollen. Diese Option sucht in allen ActiveX-Objekten, die auf Ihrem System installiert sind. Weil das sehr viele sind, kann die Suche enorm lange dauern. Einige Minuten sollten Sie schon einplanen. Diese Option ist ideal, wenn Sie einfach mal schauen wollen, ob es einen Befehl zum Thema »Battery« gibt, oder wenn Sie recherchieren möchten.
Favoriten
Überall
Tab. 2.4: Legen Sie fest, an welchen Orten gesucht werden soll
2.3
2.3.2
Nach Informationen suchen
51
Wonach suchen Sie eigentlich?
Der zweite Schritt legt fest, wonach Sie eigentlich suchen. Sind Sie auf der Suche nach einem bestimmten Befehl, oder fahnden Sie nach einem Objekt? Auch nach ProgIDs kann gesucht werden. Option
Beschreibung
Befehle Module ProgIDs
Findet Funktionen, Befehle und Eigenschaften Findet Module wie zum Beispiel das FileSystemObject oder das Folder-Modul Findet ProgIDs wie zum Beispiel Shell.Application oder Wscript.Shell
Tab. 2.5: Art der gesuchten Information festlegen
2.3.3
Wie soll gesucht werden – genau oder unscharf?
Als letzten Schritt legen Sie fest, wie gesucht werden soll. Kennen Sie den gesuchten Befehlsnamen ganz genau, dann wählen Sie wörtlich. Wollen Sie dagegen unscharf suchen, dann wählen Sie enthaltend. Jetzt werden alle Befehle gefunden, die irgendwo im Namen den Suchbegriff enthalten. Beginnend mit listet alle Befehle auf, die mit dem Suchwort beginnen. Option
Beschreibung
Wörtlich Beginnend mit Enthaltend
Suchwort wird exakt gesucht. Groß- und Kleinschreibung spielt aber keine Rolle Findet alles, was mit dem Suchwort beginnt Findet alles, was das Suchwort irgendwo im Namen enthält
Tab. 2.6: Wie genau soll gesucht werden?
2.3.4
Szenario 1: Nach einer ProgID suchen
Stellen Sie sich das folgende Beispiel vor: Sie haben in einer Zeitschrift ein Beispielscript entdeckt, das das Wscript.Network-Objekt einsetzt. Klingt interessant! Welche Möglichkeiten schlummern wohl sonst noch in diesem Objekt? Wie könnte man das Beispiel aus der Zeitschrift erweitern und ergänzen? Suchen Sie doch einfach! 1. Klicken Sie auf das Register Suchen, und wählen Sie die Option Überall. 2. Wählen Sie dann die Option ProgIDs, und wählen Sie die Option Wörtlich. 3. Geben Sie als Suchbegriff ein: Wscript.Network. Dann drücken Sie [Enter]. Voilà! Die ProgID wird gefunden, und wenn Sie den Eintrag in der Ergebnisliste anklicken, schaltet der Scripting Spy automatisch in den Röntgenschirm um, durchleuchtet das Objekt und listet Ihnen alle Funktionen auf, die das Objekt zu bieten hat. Einfach, oder?
52
Kapitel 2: Mit dem Scripting Spy geheime Systemobjekte ausspionieren
Tip: Und was, wenn das Objekt nicht gefunden wurde? Sollte Ihre Suche keinen Erfolg gehabt haben, dann ist auch das eine nützliche Information: Sie wissen so nämlich, daß dieses Objekt auf Ihrem Computer gar nicht installiert ist. Hat ein Zeitschriftenartikel zum Beispiel das Shell.Application-Objekt verwendet, so kann dieses Objekt bei Ihnen durchaus fehlen. Es wird nur vom Internet Explorer 4 mitgeliefert (nicht IE5) und steht ansonsten nur bei Windows 98 und Windows 2000 zur Verfügung.
Bild 2.7: Nach einem interessanten COM-Objekt suchen
Vielleicht sind Sie jetzt neugierig geworden und wundern sich, ob vielleicht noch ganz andere Objekte hinter Wscript. stecken. So finden Sie es heraus: 1. Klicken Sie auf das Register Suchen, und wählen Sie die Option Überall. 2. Wählen Sie die Option ProgIDs und dann die Option enthaltend. 3. Geben Sie den Suchbegriff ein: Wscript. [Enter] (Punkt nicht vergessen!) Tatsächlich: Sofort sehen Sie, daß es zusätzlich das Wscript.Shell-Objekt gibt, und per Klick sehen Sie auch dessen Funktionsvielfalt. Ziel dieser ProgID-Suche ist also, Informationen, die Ihnen durch Zeitschriftenartikel und Internetbeiträge in die Hände fallen, sofort als Saatkorn für eigene Recherchen zu nutzen.
2.4
Neue Scripting-Funktionen entdecken
53
Bild 2.8: Verwandte Objekte finden
2.3.5
Szenario 2: Nach nützlichen Befehlen suchen
Auch für die alltägliche Recherche ist die Suchen-Funktion ideal. Stellen Sie sich vor, Sie würden gern wissen, wie man den Akku-Ladestand des Notebooks ermitteln kann. Akkus heißen bei den Amerikanern vereinfachend »Battery«, also lohnt sich eine Suche nach diesem Begriff. 1. Klicken Sie auf das Register Suchen, und wählen Sie die Option Überall. 2. Wählen Sie die Option Befehle und dann die Option enthaltend. 3. Geben Sie als Suchwort ein: Battery [Enter]. Nun beginnt eine Suche quer durch alle installierten ActiveX-Komponenten. Die kann etliche Minuten dauern, läßt sich aber jederzeit abbrechen. Das ist ratsam, sobald die Suchfunktion fündig geworden ist. Und tatsächlich: Sofern Sie Windows 2000 einsetzen, wird wirklich eine Batterie-Funktion gefunden. Sie stammt aus dem Objekt SysInfo.SysInfo und heißt BatteryStatus. Ein Klick auf diesen Eintrag in der Ergebnisliste führt Sie direkt ins Röntgen-Register, und Sie sehen die genaue Befehlssyntax.
2.4
Neue Scripting-Funktionen entdecken
Vielleicht sind Sie ein alter Scripting-Hase und kennen schon die Standardbefehle der wichtigsten ActiveX-Objekte. Auch dann hat der Scripting Spy für Sie etwas zu bieten! Auf Wunsch listet er
54
Kapitel 2: Mit dem Scripting Spy geheime Systemobjekte ausspionieren
nämlich bereitwillig alle geheimen Neuerungen auf, die es seit der ersten Ausgabe eines COMObjekts gegeben hat. Dazu suchen Sie sich zunächst wie gewohnt ein ActiveX-Objekt heraus, zum Beispiel Scripting.FileSystemObject. Anschließend klicken Sie auf das Register Neue Funktionen. In der linken Liste sehen Sie jetzt alle Module, die seit der Erstausgabe dieses COM-Objekts hinzugekommen sind. Im Falle des Scripting.FileSystemObjects zeigt die Liste zum Beispiel dieses erweiterte Modul: IFileSystemObject.
Bild 2.9: Automatisch neue Funktionen eines Objekts markieren lassen
Klicken Sie darauf! Sofort zeigt die zweite Liste alle Funktionen, die im Objekt schlummern, und markiert alle neu hinzugekommenen Befehle mit »Neu«. Auf einen Blick können Sie sich so auf die wesentlichen Neuerungen konzentrieren und finden sofort heraus, daß diese Befehle beim WSH 2.0 hinzugefügt wurden: GetFileVersion GetStandardStream
2.5
VBScript und WSH durchleuchten
Das Röntgen-Register kann mehr als nur ActiveX-Objekte durchleuchten. Sie können damit jede beliebige Type Library sichtbar machen.
2.6
Hilfe zu individuellen Script-Befehlen bekommen
55
Vielleicht fragen Sie sich, wo eigentlich die VBScript-Befehle herkommen, oder Sie sind an den Befehlen interessiert, die der Windows Scripting Host mitbringt. Klicken Sie einfach auf das Röntgen-Register und dann ins Textfeld TypeLib Datei. Dann geben Sie den Dateinamen an, in dem Sie Informationen vermuten. Liegt die Datei in einem der Systemordner, dann brauchen Sie noch nicht einmal den Pfadnamen anzugeben. Hier einige gute Startpunkte: Datei
Das steckt dahinter...
Wscript.exe
Befehle des Scripting Hosts. Diese Befehle stehen Ihnen in WSH-Scripts über die Objekte Wscript oder Wsh zur Verfügung Alle Befehle der VBScript Scriptengine Alle Befehle der JScript Scriptengine
VBScript.dll Jscript.dll
Tab. 2.7: Wichtige Bibliotheken für WSH-Befehle
Bild 2.10: Aha: Direkt in WSCRIPT.EXE einklinken und die WSH-Spezialbefehle sehen
2.6
Hilfe zu individuellen Script-Befehlen bekommen
Das Röntgen-Register ist bereits eine wertvolle Hilfe: Hier listet der Scripting Spy alle Funktionen und Eigenschaften auf, die Ihr Script verwenden kann. Doch es gibt noch viel mehr Hilfestellung!
56
Kapitel 2: Mit dem Scripting Spy geheime Systemobjekte ausspionieren
Viele Objekte bringen eigens kurze Befehlsbeschreibungen mit. Sind solche Befehlsbeschreibungen verfügbar, dann blendet sie der Scripting Spy am unteren Bildschirmrand ein.
2.6.1
Geheime Hilfedateien liefern Profi-Informationen
Einige Hersteller liefern sogar ausführliche Hilfedateien mit, die haarklein die Funktion der Objekte beschreiben. Dummerweise schlummern diese Hilfedateien meist völlig vergessen irgendwo in den Weiten Ihrer Festplatte, und selbst wenn Sie durch Zufall auf eine dieser Hilfedateien stoßen würden, wäre es ein zeitraubendes Unterfangen, darin die Seite zu finden, die den gerade herausgepickten Befehl beschreibt. Der Scripting Spy macht das Leben leichter: Gibt es eine Hilfedatei zu dem Objekt, das Sie gerade untersuchen, dann blendet der Scripting Spy unten rechts die Schaltfläche Hilfe ein. Klicken Sie auf diese Schaltfläche, dann öffnet der Scripting Spy nicht nur die passende Hilfedatei, sondern blättert auch sofort vollautomatisch zu der Seite, die den ausgewählten Befehl beschreibt.
Bild 2.11: Ein Klick auf Hilfe schaltet automatisch in die Hersteller-Hilfe des Objekts
2.7
2.7
Vollautomatisch Scripts erstellen
57
Vollautomatisch Scripts erstellen
Wußten Sie eigentlich, daß der Scripting Spy sogar vollautomatisch fix und fertige Scripts für Sie schreiben kann? Sie brauchen die Scripts anschließend höchstens noch etwas feinjustieren. Zum Beispiel kann es Ihnen der Scripting Spy natürlich nicht abnehmen, die Funktionen mit den passenden Argumenten zu füttern, aber er nimmt Ihnen sämtliche Arbeit ab, um das Rahmengerüst zu gestalten. Der Scripting Spy kümmert sich auch automatisch um die richtigen Objekt-Zugehörigkeiten. Wenn Sie sich also einen Befehl aus einem Objekt aussuchen, das nicht direkt über eine ProgID und CreateObject generiert werden kann, dann schlägt der Scripting Spy zahlreiche Script-Alternativen vor, in die es alle Befehle einbaut, die nötig sind, um an das betreffende Objekt indirekt heranzukommen.
2.7.1
Szenario 1: Den Rechner scriptgesteuert herunterfahren
Schauen Sie sich einfach mal an, wie leicht so was geht. Das erste Beispiel nutzt eine Funktion aus dem Shell.Application-Objekt. Dieses Objekt gibt es bei Windows 98 und bei Windows 2000. Auf anderen Windows-Versionen fehlt es, kann aber über den Internet Explorer 4 nachgerüstet werden. Wer den Internet Explorer 5 verwendet, muß darauf verzichten. So fährt Ihr Script den Rechner herunter: 1. Starten Sie den Scripting Spy, wenn er noch nicht läuft. Ich verrate Ihnen zwar bereits, daß die gesuchte Funktion vom Objekt Shell.Application bereitgestellt wird, aber in diesem Beispiel wird keinerlei Geheimwissen vorausgesetzt. Deshalb klicken Sie auf das Register Suchen. 2. Wählen Sie die Optionen Überall, Befehl und enthaltend. Dann geben Sie als Suchwort etwas ein, das mit Herunterfahren zu tun hat und englisch ist – also Shutdown. Drücken Sie [Eingabe]. 3. Nun sucht der Scripting Spy in allen installierten Komponenten. Das kann eine Weile dauern. Gönnen Sie sich einen leckeren Capucchino, während Sie den Scripting Spy schuften lassen. 4. Nachdem die Analyse beendet ist, zeigt die Ergebnisliste eine ganze Reihe von Befehlen rund ums Thema Shutdown. Schauen Sie sich das Ergebnis genau an! Wenn bei Ihnen das Shell.Application-Objekt vorhanden ist, dann finden Sie in der Liste auch den Befehl ShutdownWindows! Der hört sich gut an – klicken Sie darauf. 5. Sofort schaltet der Scripting Spy in den Röntgenschirm um und markiert den Befehl. Unten in der Beschreibungsleiste steht: Exit Windows. Nicht übel.
58
Kapitel 2: Mit dem Scripting Spy geheime Systemobjekte ausspionieren
Bild 2.12: Suchen Sie sich heraus, welche Funktionen Ihr Windows herunterfahren
Bild 2.13: Da ist er: der Befehl zum Herunterfahren
2.7
Vollautomatisch Scripts erstellen
59
6. Nun lassen Sie den Scripting Spy ein Beispielscript schreiben. Dazu klicken Sie unten rechts auf die Schaltfläche Beispiel. Tatsächlich: der Scripting Spy schreibt Ihnen vollautomatisch ein Script.
Bild 2.14: Der Scripting Spy schreibt automatisch das passende Script für Sie
7. Klicken Sie auf Speichern, um das Script abzuspeichern. Im Speichern-unter-Fenster stellen Sie zum Beispiel oben ein: Desktop. Dann geben Sie Ihrem neuen Script einen passenden Namen, zum Beispiel Feierabend, und klicken auf Speichern. 8. Im Scripting-Spy-Fenster klicken Sie auf nächstes. Da es keine weiteren Script-Alternativen gibt, kehrt der Scripting Spy wieder in seinen Röntgenschirm zurück. Knipsen Sie den Scripting Spy aus, oder minimieren Sie sein Fenster! 9. Auf dem Desktop liegt nun Ihr Script feierabend.vbs. Ob es Windows tatsächlich herunterfährt? Starten Sie das Script! Tatsächlich: Der Bildschirm verdunkelt sich, und Windows stellt Ihnen seine Abschaltvarianten zur Verfügung. Tip: Abschalten ganz ohne Klick: geht das? Ganz vollautomatisch funktioniert das Windows-Beenden noch nicht. Der Befehl ShutdownWindows bringt nur das Beenden-Dialogfenster hervor. Wenn Sie ohne Klick sofort herunterfahren wollen, dann finden Sie weitere Lösungen in Kapitel 8.18. Und in Kapitel 12.1 zeige ich Ihnen sogar, wie Sie ferngesteuert über das Netzwerk fremde Computer herunterfahren und neu starten.
Shell.Application hat noch eine ganze Reihe weiterer Befehle zu bieten. Eine ausführliche Beschreibung finden Sie in Kapitel 5.
60
Kapitel 2: Mit dem Scripting Spy geheime Systemobjekte ausspionieren
2.7.2
Szenario 2: Den Inhalt eines Ordners auflisten
Schauen Sie sich als nächstes an, wie der Scripting Spy sogar komplexe Scripts für Sie verfaßt. Angenommen, Sie möchten die Namen aller Dateien in einem bestimmten Ordner auflisten. Aus den ersten Kapiteln wissen Sie bereits, daß für alle Datei-Operationen das Scripting.FileSystemObject zuständig ist. So gehen Sie vor: 1. Starten Sie den Scripting Spy, wenn er noch nicht läuft, und klicken Sie auf das Register Modul aussuchen. Dann klicken Sie auf das Unterregister ProgID. 2. Suchen Sie den Eintrag Scripting, doppelklicken Sie darauf, und doppelklicken Sie dann auf den Untereintrag Scripting.FileSystemObject. Vollautomatisch schaltet der Scripting Spy in den Röntgenschirm um. 3. Weil Sie Dateien auflisten wollen und weil Dateien auf englisch Files heißen, suchen Sie nach dem passenden Befehl. Dazu klicken Sie auf das Register Suchen und wählen die Optionen Aktuelles Objekt, Befehle, enthaltend. Dann geben Sie als Suchwort ein: Files [Enter]. 4. Tatsächlich: Es gibt einen Befehl namens Files. Klicken Sie ihn an! Der Scripting Host bringt Sie wieder sicher in den Röntgenschirm und markiert den Files-Befehl. Unten in der Beschreibungsleiste steht: Get files collection – schnapp dir die Sammlung der Dateien. 5. Nur: Welches Objekt bietet eigentlich den Files-Befehl an? Oben rechts in der Liste sehen Sie sofort, der Files-Befehl wird diesmal nicht direkt über ein Objekt angeboten, das Sie per ProgID und CreateObject erschaffen könnten. Statt dessen wird der Files-Befehl von einer Vielzahl anderer Funktionen bereitgestellt. 6. Bevor Sie sich nun graue Haare wachsen lassen und die Objektzusammenhänge verstehen müssten, klicken Sie einfach galant auf die Schaltfläche Beispiel, rechts unten. Voilà! Schon bastelt der Scripting Spy die erste Scriptvariation: ’ VBS Windows Script Host File ’ automatisch generiert von Scripting Spy V1.0 set FileSystemObject = CreateObject("Scripting.FileSystemObject") set Folder = FileSystemObject.CreateFolder(ByVal Path As String) set obj = Folder.Files ’ ' ' '
"files" ist vom Typ "Property " Zurückgelieferter Wert ist vom Typ: Beschreibung von "files" Get files collection
"IFileCollection"
7. Dieses Script ist zwar technisch in Ordnung, aber reichlich sinnlos. Es verschafft sich zuerst Zugang zum Scripting.FileSystemObject, legt dann mit CreateFolder einen neuen Ordner an und liest danach die Dateinamen in diesem Ordner. Ziemlich dumm, aber echte menschliche Intelligenz hat der Scripting Spy nicht zu bieten. Er ist Bürokrat. Klicken Sie deshalb auf nächstes, um sich einen neuen Vorschlag unterbreiten zu lassen. 8. Dieser Vorschlag ist schon wesentlich sinnvoller. Diesmal wird kein neuer Ordner angelegt, sondern das Script greift via GetFolder auf einen bestehenden Ordner zu. Sehr gut, genau das wollen Sie!
2.7
Vollautomatisch Scripts erstellen
61
’ VBS Windows Script Host File ’ automatisch generiert von Scripting Spy V1.0 set FileSystemObject = CreateObject("Scripting.FileSystemObject") set Folder = FileSystemObject.GetFolder(ByVal FolderPath As String) set obj = Folder.Files ’ ' ' '
"files" ist vom Typ "Property " Zurückgelieferter Wert ist vom Typ: Beschreibung von "files" Get files collection
"IFileCollection"
9. Noch ist das Script aber nicht vollständig, denn es ist nicht geklärt, welchen Ordner Sie überhaupt anschauen wollen. Hinter GetFolder steht: ByVal FolderPath As String. Strings sind Texte, hier gehört also der Pfadname des gesuchten Ordners hinein. Ersetzen Sie die Vorgabe durch einen Pfadnamen, zum Beispiel so: ’ VBS Windows Script Host File ’ automatisch generiert von Scripting Spy V1.0 set FileSystemObject = CreateObject("Scripting.FileSystemObject") set Folder = FileSystemObject.GetFolder("C:\") set obj = Folder.Files ’ ' ' '
"files" ist vom Typ "Property " Zurückgelieferter Wert ist vom Typ: Beschreibung von "files" Get files collection
"IFileCollection"
10. Speichern Sie das Script wieder ab! Wenn Sie es allerdings ausführen, wird nicht allzu viel passieren. Das ist klar: das Script verschafft sich zwar Zugriff auf einen Ordner und liefert eine »IFileCollection« zurück (das verrät das Beispielscript im unteren Teil), aber mehr passiert nicht. Damit Ihr Script sinnvoll wird, brauchen Sie aber kaum noch etwas zu tun. Lediglich wenige Erweiterungen sind nötig, und das machen Sie so: 1. Klicken Sie Ihr abgespeichertes Script mit der rechten Maustaste an, und wählen Sie Bearbeiten. Schon wird das Script-Innenleben wieder im Editor vor Ihnen ausgebreitet, und Sie können Änderungen vornehmen. 2. Wann immer Sie nicht genau wissen, was Sie mit dem Resultat eines Befehls eigentlich anfangen, lassen Sie sich den Typ des Resultats verraten. Dazu fügen Sie eine weitere Zeile hinzu: ’ VBS Windows Script Host File ’ automatisch generiert von Scripting Spy V1.0 set FileSystemObject = CreateObject("Scripting.FileSystemObject") set Folder = FileSystemObject.GetFolder("C:\") set obj = Folder.Files MsgBox TypeName(obj) ’ "files" ist vom Typ "Property " ' Zurückgelieferter Wert ist vom Typ:
"IFileCollection"
62
Kapitel 2: Mit dem Scripting Spy geheime Systemobjekte ausspionieren ’ Beschreibung von "files" ’ Get files collection
3. Speichern Sie das geänderte Script: Datei -> Speichern. Anschließend führen Sie es aus! Diesmal meldet das Script, das Ergebnis sei vom Typ Files. Aha! Schon besser! 4. Wechseln Sie zurück in den Scripting Spy. Dort ist nach wie vor das Script-Beispiel zu sehen. Klicken Sie auf Abbrechen. Klicken Sie dann auf das Register Suchen, und wählen Sie Aktuelles Objekt, Module, wörtlich. Dann suchen Sie nach files [Enter]. 5. Das Objekt wird gefunden. Es enthält nur zwei Befehle: Count und Item. Objekte, die Count und Item kennen und ansonsten nicht viele Extras zu bieten haben, sind in aller Regel Aufzählungen. Aufzählungen sind Sammelbecken, und genau das stimmt ja auch: Sie wollten die Dateien in einem Ordner sehen, und deshalb haben Sie eine Aufzählung zurückbekommen. 6. Allein mit Count könnten Sie schon eine Menge anfangen und zum Beispiel herausfinden, wie viel Dateien in einem Ordner liegen. So lassen sich auch leere Ordner identifizieren: ’ VBS Windows Script Host File ’ automatisch generiert von Scripting Spy V1.0 set FileSystemObject = CreateObject("Scripting.FileSystemObject") set Folder = FileSystemObject.GetFolder("C:\") set obj = Folder.Files MsgBox "Im Ordner befinden sich " & obj.count & " Dateien." ’ ' ' '
"files" ist vom Typ "Property " Zurückgelieferter Wert ist vom Typ: Beschreibung von "files" Get files collection
"IFileCollection"
7. Allerdings kommen Sie noch nicht an die Dateinamen heran. Dabei hilft Ihnen auch Item nicht weiter, denn Item verlangt als Argument genau den verflixten Dateinamen, den Sie ja gern herausbekommen wollen. Was nun hilft – was bei allen Aufzählungen hilft – ist der Befehl for each...next. Er listet der Reihe nach alle Elemente einer Aufzählung auf. Um also an Ihre Dateiliste heranzukommen, brauchen Sie nur zu schreiben: ’ VBS Windows Script Host File ’ automatisch generiert von Scripting Spy V1.0 set FileSystemObject = CreateObject("Scripting.FileSystemObject") set Folder = FileSystemObject.GetFolder("C:\") set obj = Folder.Files MsgBox "Im Ordner befinden sich " & obj.count & " Dateien." liste = "" For each datei in obj liste = liste & datei & vbCr Next
2.8
Fremde Programme per Script fernsteuern
63
MsgBox liste ’ ' ' '
"files" ist vom Typ "Property " Zurückgelieferter Wert ist vom Typ: Beschreibung von "files" Get files collection
"IFileCollection"
Wie flexibel Scripts sind, können Sie sofort selbst ausprobieren! Sie haben eben das Grundgerüst gebastelt, um jedwede Aufzählung sichtbar zu machen. Anstelle von Dateilisten könnten Sie sich nun auch die Unterordner oder Laufwerke Ihres Systems auflisten lassen. Ersetzen Sie einfach Set obj = Folder.Files durch Set obj = Folder.Subfolders, und schon sehen Sie alle Unterordner. Schlagen Sie anschließend Subfolders im Scripting Spy nach. Und wenn Sie die Laufwerke sehen wollen, die es auf Ihrem Computer gibt, dann ersetzen Sie die Zeile durch Set obj = FileSystemObject.Drives. Viele weitere Hintergründe und Beispielscripte zum Dateisystem und dem Scripting.FileSystemObject finden Sie im Vorgängerband: Franzis: Professional Series Scripting Praxis Buch. Tip: Aufpassen mit Count – Bug-Gefahr! Wer noch den alten WSH 1.0 verwendet, darf die Count-Eigenschaft nicht verwenden! Die liefert bei der alten WSH-Version nämlich einen Fehler und gibt nicht die Anzahl der Dateien an.
2.8
Fremde Programme per Script fernsteuern
Viele kommerzielle Programme, die Sie nachträglich installiert haben, sind ebenfalls voll scriptsteuerbar. Microsoft Word zum Beispiel bietet all seine vielfältigen Funktionen auch separat an, so daß Sie Word als universellen Server verwenden können, um zum Beispiel die Rechtschreibprüfung für eigene Projekte »auszuborgen«. Der Scripting Spy listet alle potentiell scriptfähig Programme in seinem Register Programme für Sie auf. Schauen Sie doch mal rein! Wie so etwas funktioniert und wie Sie den Scripting Spy elegant dazu einsetzen, die versteckten Funktionen installierter Programme zu nutzen, zeigt das nächste Beispiel. Es greift auf die Rechtschreibkataloge von Winword zu. Dieses Beispiel funktioniert allerdings nur, wenn Sie auch tatsächlich Winword auf Ihrem System installiert haben. Tip: TypeLibraries – lebenswichtig! Wenn Sie Programme aussuchen, dann kann es passieren, daß der Scripting Host die passende TypeLibrary zuerst suchen muß. Das liegt daran, daß die Programmhersteller ihre TypeLibraries gern verstecken und nicht in der Registry eintragen. In den meisten Fällen findet der Scripting Spy die TypeLibrary aber. Nur wenn das Programm keine TypeLibrary auf Ihrem System installiert hat, gehen Sie leer aus.
64 2.8.1
Kapitel 2: Mit dem Scripting Spy geheime Systemobjekte ausspionieren
Winwords Rechtschreibprüfung für eigene Zwecke nutzen
Sie verwenden Microsoft Word? Dann wissen Sie, daß dieses Textverarbeitungsprogramm eine eingebaute Rechtschreibprüfung besitzt. Nur: wie kommt man an die per Script heran? Der Scripting Spy hilft Ihnen! 1. Starten Sie den Scripting Spy, und klicken Sie dann auf das Register Programme. Jetzt sehen Sie die ProgIDs aller Programme, die per Script steuerbar sind. 2. Schauen Sie nach, ob in der Liste Word.Application zu sehen ist. Falls ja, ist Winword bei Ihnen installiert. Klicken Sie auf den Eintrag Word.Application. 3. Sofort schaltet der Scripting Spy in sein Röntgen-Register um und analysiert die Funktionen, die dieses Programm zu bieten hat. Weil Winword sehr viele Funktionen enthält, kann diese Analyse einige Minuten dauern. Tip: Word – und keine TypeLibrary? Dieser Schritt klappt nur, wenn auf Ihrem System auch die Word-TypeLibrary gefunden werden konnte. Fehlt sie, dann kommt auch der Scripting Spy nicht ans Innenleben von Word heran – leider. Die Beispielscripte funktionieren allerdings trotzdem.
4. Da Sie vermutlich keine Lust haben, sich durch die vielen Module durchzutasten, klicken Sie als nächstes auf das Suchen-Register. Wählen Sie dort die Optionen Aktuelles Objekt, Befehle und enthaltend. Dann geben Sie als Suchwort den englischen Begriff für Rechtschreibung ein: Spelling [Enter]. 5. Es werden zahlreiche Befehle rund um die Rechtschreibung für Sie herausgesucht. Darunter ist auch GetSpellingSuggestion. Dieser Befehl wird sowohl vom _Application-Objekt als auch vom _Global-Objekt angeboten. Wählen Sie den Befehl, den das _Application-Objekt anbietet. Tip: _Global – das steckt dahinter _Global-Objekte sind Objekte, die die Anwendung global zur Verfügung stellt. Für Scripts sind solche Objekte nicht zu gebrauchen. Versuchen Sie wann immer möglich, dieselbe Funktion aus einem anderen Objekt einzusetzen.
6. Der Scripting Spy schaltet zurück in sein Röntgen-Register und stellt die Funktion GetSpellingSuggestion dar. Klicken Sie unten rechts auf die Schaltfläche Beispiel, um ein Beispielscript zu bekommen. 7. Speichern Sie das Script mit Speichern, und legen Sie es zum Beispiel auf Ihrem Desktop als word ab. Danach minimieren Sie den Bildschirm und klicken Ihr neues Script mit der rechten Maustaste an. Wählen Sie im Kontextmenü Bearbeiten, denn Ihr Script braucht noch etwas Finetuning. 8. Der Editor öffnet sich. Verwenden Sie das automatisch generierte Script nun als Grundlage, und wandeln Sie es folgendermaßen um:
2.8
Fremde Programme per Script fernsteuern
65
’ 2-1.VBS set Application = CreateObject("Word.Application") ' ein Blankodokument hinzufügen Application.documents.Add ' nach dem Wort fragen, das korrigiert werden soll suchwort = InputBox("Geben Sie ein Wort ein!") ' Korrekturvorschläge holen set obj = Application.GetSpellingSuggestions(suchwort) ' Ergebnisse auflisten if obj.count=0 then ' keine Vorschläge! MsgBox "Ihr Wort scheint richtig geschrieben zu sein! Ich habe keine Vorschläge." else ' es gibt Vorschläge liste = "Sie haben eingegeben: " & suchwort & vbCr liste = liste & "Verbesserungsvorschläge:" & vbCr for each korrektur in obj liste = liste & korrektur & vbCr next MsgBox liste end if ' ganz wichtig: Winword nach Gebrauch wieder schließen! Application.Quit
9. Speichern Sie die Änderungen mit Datei -> Speichern. Dann schließen Sie den Editor. Sie sind fertig! Wenn Sie Ihr Script starten, fragt es nach einem beliebigen Wort. Anschließend prüft es das Wort und liefert Korrekturvorschläge. Geben Sie zum Beispiel Banhof ein, dann meldet das Script korrekt den Vorschlag: Bahnhof.
Bild 2.15: Vollautomatisch die Rechtschreibprüfung von Winword ausborgen
66
Kapitel 2: Mit dem Scripting Spy geheime Systemobjekte ausspionieren
2.8.2
Wichtige Dinge, an die Sie denken sollten
Zugegeben: Das Script erfordert noch eine ganze Reihe von Änderungen, damit es wie gewünscht läuft. Allerdings sind diese Änderungen stets gleicher Natur, so daß Sie lediglich ein paar Hintergründe zu kennen brauchen:
Bevor Sie die Funktionen eines fremden Programms nutzen können, muß es in vielen Fällen zuerst ein Dokument laden. Ohne Dokument geht das Programm davon aus, daß Sie seine Funktionen einfach nur kidnappen. Das stimmt ja eigentlich auch, und deshalb ist es wichtig, das Programm mit einem Dummy-Dokument in dem Glauben zu lassen, seine Funktionen würden intern verwendet. Bei Word legen Sie ein neues Dokument mit Application.Documents.Add an.
Häufig werden Ergebnisse als sogenannte Collection zurückgeliefert. Collections sind Sammlungen von einzelnen Objekten oder Informationen. Das Beispielscript prüft zum Beispiel mit Count, ob die zurückgelieferte Collection überhaupt Elemente enthält. Wenn nicht, kann es davon ausgehen, daß keine Korrekturvorschläge existieren. Andernfalls setzt es for each...next ein, um die einzelnen Elemente der Collection auszulesen.
Machen Sie sich immer bewußt, daß Ihr Script ein vollwertiges Programm gestartet hat. Das Programm ist zwar unsichtbar, existiert aber. Deshalb ist es unbedingt nötig, daß Ihr Script dieses Programm nach Gebrauch auch wieder schließt. Andernfalls würde das Programm weiter im Speicher bleiben und so lange Ressourcen fressen, bis der Computer neu gestartet wird. Deshalb beendet das Script Winword zum Schluß mit Quit. Tip: Mit GetObject direkt auf Dokumente zugreifen In Kapitel 3.4.4 lernen Sie den GetObject-Befehl kennen. Mit dessen Hilfe verschaffen Sie sich direkten Zugriff auf ein bestimmtes Dokument und könnten so zum Beispiel auf direktem Wege ein WordDokument öffnen. Das ist sinnvoll, wenn Sie die Word-Funktionen nicht losgelöst von einem Dokument verwenden, sondern auf ein bestimmtes Dokument anwenden möchten.
2.8.3
Noch mehr Automation: Automatisch Texte korrigieren
Eben haben Sie die Rechtschreibprüfung kennengelernt und konnten einzelne Wörter einfüttern. Als Test ist das ausreichend, aber in der Praxis viel interessanter sind Scripts, die zum Beispiel Textdateien vollautomatisch korrigieren. Das nächste Script liest ein beliebiges Textdokument ein und korrigiert seinen gesamten Inhalt. Fehler, die einmal korrigiert wurden, werden vom Script automatisch erneut korrigiert, sollten sie noch einmal auftreten. Das Script zeigt das Grundprinzip, ist aber noch nicht besonders komfortabel. Es liest die Beispieldatei C:\BEISPIEL.TXT ein und prüft dann Wort für Wort den Text darin. Bei falschgeschriebenen Wörtern zeigt das Script die Auswahl an Korrekturvorschlägen an, die vom Anwender allerdings noch von Hand eingegeben werden müssen.
2.8
Fremde Programme per Script fernsteuern
67
Immerhin brauchen Fehler nur ein einziges Mal korrigiert zu werden. Das Script merkt sich Korrekturen in einem Scripting.Dictionary-Objekt und korrigiert mehrfach auftretende Fehler anschließend automatisch. Die korrigierte Version des Textes speichert das Script in der Datei C:\BEISPIEL2.TXT. Bevor Sie dieses Script ausprobieren, legen Sie mit dem Texteditor Notepad eine Datei mit falschgeschriebenen Wörtern an und speichern sie als C:\BEISPIEL1.TXT. ’ 2-2.VBS set fs = CreateObject("Scripting.FileSystemObject") set dict = CreateObject("Scripting.Dictionary") set Application = CreateObject("Word.Application") Application.documents.Add ’ file = Originaldatei mit Fehlern ’ file2 = korrigierter Text set file = fs.OpenTextFile("c:\beispiel.txt") set file2 = fs.CreateTextFile("C:\beispiel2.txt", true) do until file.atEndOfStream wort = GetWord(file, bindung) ’ wurde das Wort schon korrigiert? if dict.exists(wort) then ’ ja, also vorhandene Korrektur verwenden wort = dict(wort) else ' nein, also Vorschläge holen sugg = GetSuggestions(wort) ' gibt es Vorschläge? if not sugg = "" then ' ja, also Benutzer fragen, welcher Vorschlag ' verwendet werden soll newwort = InputBox("Sie haben eingegeben: " & _ vbCr & wort & vbCr & "Vorschläge:" _ & vbCr & sugg,,wort) dict.Add wort, newwort wort = newwort end if end if ' korrigiertes Wort in neue Datei schreiben file2.Write wort & bindung loop file.close file2.close ' ganz wichtig: Winword nach Gebrauch wieder schließen! Application.Quit
68
Kapitel 2: Mit dem Scripting Spy geheime Systemobjekte ausspionieren
function GetWord(obj, zeichen) ’ liest aus der Textdatei genau ein Wort ' liefert das Wort zurück und meldet in zeichen das ' Zeichen, das dem Wort folgt do until obj.atEndOfStream zeichen = obj.Read(1) if (zeichen=" " or zeichen=vbCr or zeichen=vbLf) then exit do else GetWord = GetWord & zeichen end if loop end function function GetSuggestions(wort) ' liefert alle Korrekturvorschläge für ein Wort zurück set obj = Application.GetSpellingSuggestions(wort) if obj.count=0 then exit function else for each korrektur in obj GetSuggestions = GetSuggestions & korrektur & vbCr next end if end function
Bild 2.16: Automatische und lernfähige Rechtschreibkontrolle
69
3
Die eingebauten WSH-Befehle: Wscript-Objekt
Der Windows Scripting Host bringt – völlig unabhängig von der Scriptsprache, die Sie einsetzen – eine ganze Reihe von nützlichen Befehlen mit. Diese Befehle können über die Objekte Wscript oder Wsh angesprochen werden. Weil beide Objekte nur zur Verfügung stehen, wenn Ihr Script über den Scripting Host ausgeführt wird, können die Funktionen in diesem Kapitel nicht innerhalb von HTML-Scripts eingesetzt werden.
3.1
Informationen über den Scripting Host
Arbeiten Sie mit der aktuellsten WSH-Version? Wo genau ist WSCRIPT.EXE gespeichert? Wird Ihr Script gerade mit der Windows-Version oder der DOS-Version des WSH ausgeführt? All diese Fragen beantwortet das Wscript-Objekt: Befehl
Beschreibung
Application BuildVersion FullName Name Path Version
Referenz auf den WSH; entspricht den vordefinierten Objekten Wscript und Wsh Interne Versionsnummer Pfadname des Scripting Host Executables Klartextname (Beschreibung) des WSH Pfad zum Ordner, in dem der WSH gespeichert ist Versionsnummer des WSH
Tab. 3.1: Die internen Befehle des Scripting Host
3.1.1
Das Application-Objekt
Application liefert eine Instanz des WSH-Objekts selbst zurück. Dieser Befehl ist deshalb eigentlich völlig sinnlos, denn der WSH blendet sich selbst sowieso über die Standardobjekte Wscript und Wsh ein. Daß alle drei Objekte in Wirklichkeit ein und dasselbe Objekt sind, beweist das folgende Script: ’ 3-1.vbs set obj = wscript.application MsgBox TypeName(obj) MsgBox obj is wsh MsgBox obj is Wscript
70 3.1.2
Kapitel 3: Die eingebauten WSH-Befehle: Wscript-Objekt
Die Version des WSH ermitteln
Der Scripting Host wird ständig weiterentwickelt, und oben hatten Sie bereits gesehen, wie Sie mit dem Scripting Spy neu hinzugekommene Funktionen entdecken. Falls Sie in Ihren Scripts solche neuen Funktionen einsetzen und sichergehen wollen, daß es auf Computern mit älterem WSH keine Probleme gibt, dann bestimmen Sie einfach die Version: ’ 3-2.VBS bv = "Build-Version: " & WScript.BuildVersion v = "Version: " & WScript.Version MsgBox v & vbCr & bv
Wundern Sie sich nicht, daß der WSH 2.0 als Versionsnummer 5.1 zurückliefert. Die interne Version hat nichts mit der offiziellen Release-Version zu tun.
3.1.3
Pfadnamen und geheime Antworten
Die Eigenschaften Name, FullName und Path sind auf den ersten Blick wenig hilfreich, verraten sie doch nur, wo der WSH wohnt: ’ 3-3.vbs n = "Name: " & wscript.name fn = "FullName: " & wscript.fullname p = "Path: " & wscript.path msg = n & vbCr & fn & vbCr & p MsgBox msg, vbInformation
Auf den zweiten Blick wird die Sache allerdings immens wichtig. Wie Sie inzwischen wissen, gibt es zwei Versionen des WSH: WSCRIPT.EXE und CSCRIPT.EXE. WSCRIPT.EXE führt Ihr Script als Windows-Programm aus, während CSCRIPT.EXE dazu ein DOS-Fenster öffnet.
Bild 3.1: Herausfinden, wo der Kern des Scripting Host eigentlich gespeichert ist
Vor allem wenn Sie planen, ein DOS-Fenster für die Ein- und Ausgabe zu nutzen, brauchen Sie einen Weg, um festzustellen, ob das Script mit WSCRIPT.EXE oder CSCRIPT.EXE ausgeführt wird. Diese Information liefert FullName: ’ 3-4.VBS fn = wscript.fullname engine = mid(fn, InstrRev(fn, "\")+1) MsgBox "Dieses Script wird ausgeführt von: " & engine
3.1
Informationen über den Scripting Host
71
Starten Sie dieses Script normal, dann meldet es Wscript.exe als Ausführungsorgan. Klicken Sie dagegen das Script mit der rechten Maustaste an und wählen Mit Eingabeaufforderung öffnen, dann meldet es korrekt Cscript.exe.
Bild 3.2: Herausfinden, ob Scripts in der DOS-Box laufen
Falls Sie also ein Script unbedingt in einem DOS-Fenster ausführen wollen, aber nicht darauf vertrauen können, daß der Anwender von selbst den richtigen Startbefehl gibt, dann wäre dies eine Lösung: ’ 3-5.VBS ' läuft das Script mit CSCRIPT.EXE? if not isDOS then ' NEIN, also an CSCRIPT.EXE verfüttern und diese Instanz ' beenden: set wshshell = CreateObject("WScript.Shell") wshshell.Run "CSCRIPT.EXE """ & wscript.ScriptFullName & """" wscript.quit end if ' dieser Teil wird IMMER von CSCRIPT ausgeführt ' hier können also gefahrlos Streams verwendet werden set instream = WScript.StdIn set outstream = WScript.StdOut outstream.WriteLine "Huhu, geben Sie etwas ein!" outstream.WriteLine "quit beendet den Test." outstream.Write time & "> " do lies = instream.ReadLine ' abbrechen, wenn der Benutzer "quit" eingibt if lcase(lies)="quit" then exit do ' dieses Script verwandelt die Eingabe nur in Großbuchstaben ' hier könnten auch sinnvollere Dinge passieren outstream.WriteLine ucase(lies) outstream.Write time & "> " loop MsgBox "Tschau!" function isDOS fn = wscript.fullname engine = lcase(mid(fn, InstrRev(fn, "\")+1)) if engine = "wscript.exe" then
72
Kapitel 3: Die eingebauten WSH-Befehle: Wscript-Objekt
isDOS = false else isDOS = true end if end function
Bild 3.3: Automatisch ein Script im DOS-Fenster mit interaktiven Eingaben erstellen
3.2
Informationen über das Script bekommen
Der WSH liefert auf Wunsch detaillierte Informationen über das Script, das gerade ausgeführt wird: Befehl
Beschreibung
ScriptFullName ScriptName
Pfadname des Scripts Name des Scripts
Tab. 3.2: Informationen über den Speicherort eines Scripts
3.2.1
Begleitinformation aus dem Scriptordner öffnen
ScriptFullName und ScriptName liefern zunächst nur Namen bzw. Pfadnamen des gerade ausgeführten Scripts. Dies allein ist nicht sehr spannend: ’ 3-6.VBS sn = "ScriptName: " & wscript.ScriptName sfn = "ScriptFullName: " & wscript.ScriptFullName MsgBox sn & vbCr & sfn
3.2
Informationen über das Script bekommen
73
In diesen Informationen stecken jedoch Juwelen: ScriptFullName enthält den Ordner, in dem das aktuelle Script gespeichert ist. Wenn Sie also Begleitinformationen in diesem Ordner speichern möchten, dann filtern Sie einfach den Ordnernamen aus dem Pfadnamen des Scripts heraus.
Bild 3.4: Herausfinden, wo ein Script gelagert wird
3.2.2
Logbuch-Datei: Wann und wie oft wird ein Script benutzt?
Das nächste Beispiel unterhält in demselben Ordner, in dem es gespeichert wird, eine Logbuchdatei, die darüber Buch führt, wie oft und wann das Script aufgerufen wird. Klar ist, daß dies nicht funktioniert, solange das Script auf einer schreibgeschützten CD untergebracht ist. ’ 3-7.VBS ’ Script notieren LogMe ' hier könnten weitere Aufgaben erledigt werden sub LogMe ' in welchem Pfad liegt dieses Script? sfn = wscript.ScriptFullName pfad = left(sfn, InstrRev(sfn, "\")) ' Logbuchdatei anlegen logfilename = pfad & "logbuch.txt" set fs = CreateObject("Scripting.FileSystemObject") set file = fs.OpenTextFile(logfilename, 8, true) ' Logbuch-Eintrag hineinschreiben: file.WriteLine "Script " & wscript.scriptname _ & " gestartet: " & now file.close end sub
Bild 3.5: Protokollieren, wann Scripts ausgeführt wurden
74
Kapitel 3: Die eingebauten WSH-Befehle: Wscript-Objekt
3.3
Drag&Drop: Argumente ans Script übergeben
Ihr Script kann externe Informationen per Drag&Drop oder per Kommandozeilen-Argument einlesen. Darüber hinaus kann der WSH 2.0 auch ein DOS-Fenster für Ein- und Ausgaben verwenden: Befehl
Beschreibung
StdErr StdIn StdOut Arguments Echo
DOS-Stream für Fehlermeldungen DOS-Stream für Texteingaben DOS-Stream für Textausgaben Ans Script übergebene Argumente Informationen in DOS-Fenster oder Dialogfenster ausgeben
Tab. 3.3: Befehle, mit denen externe Argumente gelesen und Antworten ausgegeben werden
3.3.1
Argumente an Scripts verfüttern
Ihre Scripts sind kommunikativ! Sie können zum Beispiel Dateien auf einem Script-Icon fallen lassen und dann die Dateinamen auslesen. Anschließend könnte Ihr Script mit den Dateien tun, was es gerade mag. Neben dem schicken Drag&Drop sind aber auch die klassischen Befehlszeilen-Optionen möglich. Die sind besonders für Scripts wichtig, die in einem DOS-Fenster ausgeführt werden. Sie funktionieren wie die Befehlszeilenargumente bei normalen DOS-Befehlen. Praktisch dabei: Beide Varianten funktionieren intern genau gleich. Ihr Script akzeptiert also Argumente sowohl über die Kommandozeile als auch per Drag&Drop. Wichtige Fallen: Drag&Drop ist erst ab dem WSH 2.0 möglich, und die Gesamtlänge der Argumente darf die maximale Pfadnamen-Länge von 260 Zeichen nicht überschreiten. Hier eine Kostprobe: ’ 3-8.VBS ’ Argumente auslesen set args = wscript.Arguments ' wieviel Argumente wurden übergeben? if args.Count=0 then ' gar keine! MsgBox "Keine Argumente übergeben!" else liste = "" for each argument in args cc=cc+1 liste = liste & cc & ". Argument: " & argument & vbCrLf next WScript.Echo liste end if
3.3
Drag&Drop: Argumente ans Script übergeben
75
Sie können nun entweder Dateien auf Ihr Script-Icon ziehen. Jeder Dateiname wird als eigenständiges Argument gelesen.
Bild 3.6: Argumente per Drag&Drop oder als Kommandozeilenargument übergeben
Oder Sie nutzen Kommandozeilen-Argumente: 1. Wählen Sie im Startmenü Ausführen, und geben Sie ein: WSCRIPT.EXE. Fügen Sie ein Leerzeichen hinzu, und ziehen Sie dann Ihr Script in die Befehlszeile. Windows schreibt den Pfadnamen dahinter. 2. Fügen Sie noch ein Leerzeichen und dann Ihre Argumente an. Dann drücken Sie [Enter]. Korrekt gibt das Script die Argumente wieder aus. Die einzelnen Argumente werden dabei durch die Leerzeichen voneinander getrennt. Wollen Sie Leerzeichen im Argument, dann setzen Sie das Argument in Anführungszeichen.
3.3.2
Scripts als DOS-Befehle einsetzen
Natürlich ist die Befehlszeilen-Variante reichlich unbequem: wer hat schon Lust, umständlich Wscript.exe voranzustellen und dann auch noch den ganzen langen Pfadnamen des Scripts einzugeben? Als echte Ergänzung zu DOS-Befehlen eignen sich Scripts nur auf Windows 2000-Systemen, dort dafür aber hervorragend. Windows 2000 ist nämlich schlau genug, WSH-Scripts auch ohne vorangestelltes WSCRIPT.EXE auszuführen. Selbst die Endung .vbs kann weggelassen werden. Und wenn Sie Ihre Scripts in einem Systemordner speichern, der Teil des allgemeinen Pfades ist, dann brauchen Sie noch nicht einmal den Pfadnamen anzugeben – ideal. Das Beispielscript von oben würde also bei Windows 2000 wie im folgenden Bild verwendet werden können. Tip: Ausgaben ins DOS-Fenster schreiben Damit sich Ihr Script tatsächlich wie ein echter DOS-Befehl benimmt, müssen Sie nur die Scriptengine auf CSCRIPT umstellen. Wählen Sie im Startmenü Ausführen, und geben Sie ein: WSCRIPT //H:CSCRIPT [Enter]. Mit WSCRIPT //H:WSCRIPT [Enter] schalten Sie zurück in den Windows-Modus. WScript.Echo sorgt dafür, daß die Ausgabe im CSCRIPT-Modus ins DOS-Fenster geschrieben wird.
76
Kapitel 3: Die eingebauten WSH-Befehle: Wscript-Objekt
Bild 3.7: Windows 2000 akzeptiert Scriptnamen als »DOS-Befehle«
3.3.3
Mit den DOS-Streams Ein- und Ausgaben ins DOS-Fenster machen
Scripts lassen sich nicht nur bequem von DOS aus mit Argumenten füttern (jedenfalls bei Windows 2000), sie können sich auch sonst wie DOS-Befehle benehmen. Ihre Scripts könnten also eigene Ergebnisse ins DOS-Fenster schreiben und von dort Eingaben empfangen. Sogar das Piping wird unterstützt: Scripts können Eingaben nahtlos von anderen Scripts oder echten DOS-Befehlen empfangen. Über StdErr, StdIn und StdOut klinken sich Ihre Scripts in die DOS-Streams ein: Stream
Bedeutung
StdErr StdIn
Fehlermeldungen des DOS-Fensters an das Script Eingaben an Ihr Script, die entweder interaktiv vom Anwender angegeben werden oder per Piping von einem anderen Script übergeben werden Ausgaben, die das Script ins DOS-Fenster schreibt
StdOut
Tab. 3.4: Die Kommunikationskanäle zum DOS-Fenster
Voraussetzung dafür ist, daß es überhaupt ein DOS-Fenster gibt. Führen Sie ein Script mit Wscript.exe aus, dann kassieren Sie einen Fehler, sobald Sie versuchen, einen der DOS-Streams anzusprechen. Deshalb müssen Sie entweder darauf vertrauen, daß der Scriptanwender das Script aus einem DOS-Fenster aus aufruft, oder Sie wenden den Trick von Script 3-5.VBS, der sicherstellt, daß CSCRIPT.EXE zum Zuge kommt. Das folgende Script ist das Grundgerüst für einen Pseudo-DOS-Befehl. Das Script akzeptiert zwei Kommandozeilen-Optionen: /test: und /?. ’ 3-9.VBS ' sicherstellen, daß Script im DOS-Fenster läuft DOSonly
3.3
Drag&Drop: Argumente ans Script übergeben
77
' ab hier läuft das Script IMMER im DOS-Fenster, ' deshalb können jetzt die DOS-Streams gefahrlos eingesetzt ' werden: set instream = WScript.StdIn set outstream = WScript.StdOut ' Argumente auslesen set args = wscript.Arguments if args.count = 0 then outstream.WriteLine "Es wurden keine Argumente angegeben!" WScript.Quit end if ' Argumente auswerten for each arg in args if arg="/?" then outstream.WriteLine "Dies ist ein Testprogramm" outstream.WriteLine "/test:text gibt Text in " _ & "Großbuchstaben aus" outstream.WriteLine "/? zeigt diese Hilfe" WScript.Quit elseif left(lcase(arg),6)="/test:" then outstream.WriteLine ucase(mid(arg,7)) else outstream.WriteLine "Unbekanntes Argument: " & arg end if next sub DOSonly fn = wscript.fullname engine = lcase(mid(fn, InstrRev(fn, "\")+1)) if engine = "wscript.exe" then set wshshell = CreateObject("WScript.Shell") ' Argumente mit übergeben arglist = "" for each arg in wscript.Arguments arglist = arglist & """" & arg & """ " next wshshell.Run "%COMSPEC% /K CSCRIPT.EXE """ _ & wscript.ScriptFullName & """ " & arglist wscript.quit end if end sub
Wenn Sie dieses Script aufrufen, schaltet es automatisch in ein DOS-Fenster. Erreicht wird dies, weil sich das Script im Bedarfsfall selbst aufruft, dabei CSCRIPT.EXE verwendet und CSCRIPT.EXE in einem eigens geöffneten DOS-Fenster anzeigt. Dazu lädt es mit %COMSPEC% zuerst den DOS-Kommandozeilen-Interpreter und sorgt mit der Option /K dafür, daß das Fenster offen bleibt, nachdem das Script seine Arbeit getan hat.
78
Kapitel 3: Die eingebauten WSH-Befehle: Wscript-Objekt
Machen Sie den Test: 1. Starten Sie das Script. Ein DOS-Fenster öffnet sich, und das Script meldet darin, daß keine Argumente übergeben wurden. Das stimmt. 2. Rufen Sie das Script aus dem DOS-Fenster erneut auf, und verwenden Sie dabei das Argument /?. Diesmal zeigt das Script Hilfe-Informationen an. 3. Verwenden Sie dann das Argument /test:text. Diesmal gibt das Script den Text hinter dem Schalter /test: in Großbuchstaben aus. Enthält der Text Leerzeichen, dann muß er in Anführungszeichen gesetzt werden. Allerdings bleibt ein Manko: Jedesmal, wenn Sie das Script von neuem aufrufen, wird auch ein neues DOS-Fenster geöffnet. Das ist verständlich, denn als Vorgabe verfüttert der WSH jedes Script zuerst an Wscript.exe, ganz gleich, ob Sie das Script per Maus oder vom DOS-Fenster aus öffnen. Wollen Sie hauptsächlich mit der Kommandozeile arbeiten, dann gibt es einen wesentlich einfacheren Weg: Weisen Sie den WSH an, künftig alle Scripts von vornherein direkt mit CSCRIPT.EXE zu starten: Befehl
Bedeutung
Wscript.exe //H:Cscript Wscript.exe //H:Wscript
Alle Scripts werden mit CSCRIPT.EXE geladen Alle Scripts werden mit WSCRIPT.EXE geladen (Voreinstellung)
Tab. 3.5: Umschaltung zwischen DOS- und Windows-Scripting Host
3.3.4
Piping – Ergebnisse von anderen Befehlen verfeinern
Wie Sie mit StdIn Eingaben vom Scriptbenutzer erfragen, hat bereits Script 3-5.VBS gezeigt. Ebenfalls interessant ist Piping. Piping ist das Verketten mehrerer Befehle und bei DOS schon lange üblich. Wenn Sie zum Beispiel mit dem DOS-Befehl DIR ein langes Ordnerlisting ausgeben und verhindern wollen, daß das Listing nur so an Ihnen vorbeirauscht, dann könnten Sie das Ergebnis an den DOS-Befehl MORE weiterleiten. MORE hält dann die Ausgabeflut jeweils bildschirmweise an und wartet auf einen Tastendruck. Probieren Sie’s einfach aus: 1. Öffnen Sie zunächst ein DOS-Fenster: Wählen Sie im Startmenü Ausführen, und geben Sie ein: %COMSPEC% [Enter]. 2. Geben Sie dann ins Fenster ein: DIR C:\ [Enter]. Das DOS-Listing saust vorbei. 3. Nun setzen Sie Piping ein. Geben Sie dazu ein: DIR C:\ | MORE [Enter]. Diesmal wird das Listing nach jeder Seite angehalten.
3.3
Drag&Drop: Argumente ans Script übergeben
79
Tip: DIRCMD – vorgefertigte DIR-Optionen Wenn DIR bei Ihnen nicht die normale vorbeisausende Ausgabe erzeugt, dann sind wahrscheinlich erweiterte Optionen angegeben worden. Die werden in der Umgebungsvariablen DIRCMD gespeichert. Mit SET DIRCMD= [Enter] löschen Sie solche Optionen.
Das Piping-Zeichen ist also das |-Zeichen, das Sie über [AltGr]+[<] erhalten. Dieses Zeichen verkettet mehrere Befehle miteinander, und das funktioniert auch bei Scripts. ’ 3-10.VBS ' sicherstellen, daß Script im DOS-Fenster läuft DOSonly ' ab hier läuft das Script IMMER im DOS-Fenster, ' deshalb können jetzt die DOS-Streams gefahrlos eingesetzt ' werden: set instream = WScript.StdIn set outstream = WScript.StdOut do until instream.atEndOfStream outstream.WriteLine ucase(instream.ReadLine) loop outstream.WriteLine "Fertig." sub DOSonly fn = wscript.fullname engine = lcase(mid(fn, InstrRev(fn, "\")+1)) if engine = "wscript.exe" then set wshshell = CreateObject("WScript.Shell") path = left(wscript.scriptfullname, _ InstrRev(wscript.ScriptFullName, "\")) wshshell.Run "%comspec% /k cd " & path MsgBox "Starten Sie Script mit CSCRIPT.EXE!", _ vbSystemModal wscript.quit end if end sub
Dieses Script demonstriert Piping. Wenn Sie das Script per Mausklick starten und nicht CSCRIPT.EXE als Standard-Engine verwenden, dann öffnet es ein DOS-Fenster und stellt als Pfad den Ordner ein, in dem das Script schlummert. Das ist ideal, weil Sie so nicht den gesamten Pfadnamen des Scripts eingeben müssen. Piping funktioniert bei Scripts nur, wenn Sie CSCRIPT.EXE explizit angeben. Probieren Sie es aus, und geben Sie im DOS-Fenster ein: CSCRIPT.EXE 3-10.VBS [Enter]. Alles, was Sie nun eingeben, wird vom Script in Großbuchstaben zurückgeliefert. Das geht so lange, bis Sie den Eingabestrom mit [Strg]+[C] abbrechen. Intern ist dafür eine do...loop-Schleife zuständig, die so lange auf Eingaben wartet, bis der Eingabestream atEndOfStream meldet.
80
Kapitel 3: Die eingebauten WSH-Befehle: Wscript-Objekt
Das ist natürlich noch kein Piping. Geben Sie deshalb als nächstes ein: DIR C:\ | cscript.exe 3-10.vbs [Enter].
Diesmal wird zuerst der DIR-Befehl ausgeführt und füttert die Eingabe direkt ins Script. Das Script wandelt die Eingabe erneut in Großbuchstaben um und gibt sie schließlich aus. Natürlich könnten Sie hier ganz andere Dinge tun. Vielleicht wollen Sie einen Filter schreiben, der bestimmte Informationen aus DOS-Befehlsergebnissen herausfiltert. So könnten Sie zum Beispiel den DOS-Befehl CHKDSK aufrufen und das Ergebnis per Piping an Ihr Script weiterleiten. Das Script könnte dann aus diesen Informationen die für Sie wichtigen Details herauspicken und anschließend in eine Datei schreiben oder ausgeben. Tip: Aufpassen: DOS-Befehle arbeiten unterschiedlich! Wenn Sie Ergebnisse von DOS-Befehlen »parsen«, also interessante Details herauspicken wollen, dann denken Sie daran: Die DOS-Befehle heißen zwar bei allen Windows-Versionen gleich, funktionieren aber ganz anders. CHKDSKs Ergebnisse sind bei Windows 95, 98 und NT vollkommen unterschiedlich aufgebaut.
3.3.5
Mit Echo: Ergebnisse direkt ans DOS-Fenster
Auch ohne Piping kann Ihr Script Ausgaben in ein DOS-Fenster machen. Hierfür ist der Befehl Echo gedacht: Läuft Ihr Script mit Wscript.exe, dann erscheint ein Dialogfenster. Wird Ihr Script dagegen mit Cscript.exe ausgeführt, dann landen Ihre Ausgaben als Text im DOS-Fenster. ’ 3-11.VBS WScript.Echo "Diese Ausgabe stammt von Echo" MsgBox "Fertig!"
Wenn Sie dieses Script öffnen, erscheint die Meldung von Echo in einem Dialogfenster. Es unterscheidet sich nur durch seinen Titelleisten-Text von der MsgBox-Meldung. Führen Sie Ihre Scripts dagegen mit Cscript.exe aus, dann schreibt Echo seine Meldung ins DOSFenster. Um das auszuprobieren, klicken Sie einfach mit der rechten Maustaste auf das Script-Icon und wählen Mit Eingabeaufforderung öffnen. Tatsächlich schreibt Echo nun ins DOS-Fenster. Echo hat zwei Einsatzbereiche:
Erstens kann es als Ausgabemethode dienen, wenn die Script-Engine keine eigene Ausgabemethode kennt. VBScript versorgt Sie mit dem MsgBox-Befehl, der wesentlich mächtiger ist als Echo. JScript dagegen kennt überhaupt keine Ausgabe-Befehle und ist deshalb allein auf Echo angewiesen.
Zweitens kann Echo dazu gebraucht werden, in selbstdefinierten Kommandozeilen-Scripts Ergebnisse direkt ins DOS-Fenster auszugeben. Im Gegensatz zu den DOS-Streams ist Echo wesentlich pflegeleichter, weil es notfalls einfach auf das Dialogfenster ausweicht, sollte kein DOS-Fenster zur Verfügung stehen.
3.4
3.4
Mit Events arbeiten
81
Mit Events arbeiten
Events sind Alarmmeldungen von externen Objekten. Über Events kann ein externes Objekt, mit dem Ihr Script gerade arbeitet, wichtige Ereignisse sofort melden. Ihr Script kann auf diese Ereignisse sofort reagieren, ganz gleich, womit das Script gerade beschäftigt war. Befehl
Beschreibung
ConnectObject CreateObject
Klinkt sich in ein bereits aktives Objekt nachträglich ein, um seine Events abzuhören Funktioniert fast wie der VBScript-Befehl CreateObject, verbindet das Script aber gleichzeitig mit den Events des Objekts Beendet die Event-Verbindung zum angegebenen Objekt Klinkt sich in ein bereits aktives Objekt nachträglich ein, um eine Referenz darauf zu erhalten und seine internen Methoden verwenden zu können
DisconnectObject GetObject
Tab. 3.6: Funktionen, um auf Events zuzugreifen
3.4.1
CreateObject: Geheimtür zu fremden Objekten
Der CreateObject-Befehl ist der wohl wichtigste VBScript-Befehl für professionelle Scripter, denn er erlaubt, fremde Objekte anzusprechen und ihre internen Befehle zu nutzen. Während der normale VBScript-Befehl CreateObject keine Events unterstützt, kann alternativ der CreateObject-Befehl von Wscript zum Zuge kommen. Der verbindet Ihr Script nicht nur mit dem Objekt, sondern stellt gleichzeitig eine Verbindung zu den Events des Objekts her. Wie so etwas in der Praxis aussieht, zeigt das nächste Script. Es öffnet eine Instanz des Internet Explorers und wartet dann darauf, daß jemand dieses Fenster schließt. Sobald dies passiert, feuert der Internet Explorer als eine seiner letzten Aktionen den Event onQuit ab, und genau den empfängt Ihr Script. ’ 3-12.VBS ' Internet Explorer öffnen und Events abhören set ie = WScript.CreateObject("InternetExplorer.Application", _ "event_") ie.Visible = true ' 20 Sekunden auf Event warten WScript.Sleep 20000 ' immer noch nicht geschlossen? Dann selbst schließen: MsgBox "Lange genug gewartet – ich schließ das Ding " _ & "jetzt selber.", vbSystemModal ie.Quit ' noch 2 Extrasekunden warten, um den Event nicht zu ' verpassen: WScript.Sleep 2000
82
Kapitel 3: Die eingebauten WSH-Befehle: Wscript-Objekt
sub event_onQuit ' wird ausgeführt, sobald onQuit gefeuert wird MsgBox "IE wird jetzt geschlossen!", vbSystemModal WScript.Quit end sub
Wenn Sie das Script starten, öffnet es ferngesteuert ein Internet Explorer-Fenster. Danach legt sich das Script via Sleep für 20 Sekunden (20.000 Millisekunden, um genau zu sein) schlafen. Aufgeweckt werden kann es in dieser Zeit nur von Events. Anstelle von Sleep könnte das Script aber ebenso gut auch weitere Aufgaben ausführen. Sleep ist keine Voraussetzung, um Events zu empfangen. Sobald der Internet Explorer geschlossen wird, empfängt das Script den onQuit-Event. Weil Wscript.CreateObject als zweites Argument einen Eventhandler angegeben hat (»event_«), wird nun die Sub-Funktion ausgeführt, die mit diesem Handler beginnt und dahinter im Namen den Namen des Events trägt. Es wird also die Sub-Prozedur event_onQuit ausgeführt. Die meldet kurz das Ereignis und beendet dann das Script. Wird der Internet Explorer während der 20sekündigen Überwachung nicht geschlossen, dann macht das Script es eben selbst und ruft die Quit-Methode des Internet Explorers auf. Auch hierbei wird ein onQuit-Event ausgelöst, den Ihr Script nur deshalb noch empfängt, weil es anschließend noch einmal zwei Sekunden auf Events hört. Ohne den zweiten Sleep-Befehl würde das Script bereits beendet sein, wenn der Event ausgelöst wird.
Bild 3.8: Der Scripting Spy informiert Sie über alle Events, die ein Objekt abfeuern kann
3.4
Mit Events arbeiten
83
Ob ein Objekt Events unterstützt – und welche das sind –, verrät wieder Ihr Scripting Spy: 1. Starten Sie den Scripting Spy, und suchen Sie sich dann im Register Modul aussuchen das Objekt InternetExplorer.Application heraus. Doppelklicken Sie darauf. 2. Sofort sehen Sie, daß das Objekt über Events verfügt, und zwar sogar über sehr viele. Klicken Sie in der oberen Liste auf das Event-Interface. Es ist mit diesem Symbol markiert: . Sie sehen: OnQuit ist nur einer von zahlreichen möglichen Events. 3. Klicken Sie nun oben in der Liste noch einmal auf das Standard-Interface. Es ist mit diesem Symbol markiert: BILD. Jetzt sehen Sie alle Funktionen und Befehle, die der Internet Explorer unterstützt. Auch hier sehen Sie sofort: Visible und Quit, die im Script oben eingesetzt wurden, sind nur zwei von vielen.
3.4.2
ConnectObject: Eventüberwachung einschalten
Falls Sie bereits eine Referenz auf ein Objekt besitzen und nachträglich auch dessen Events empfangen wollen, dann setzen Sie ConnectObject ein. Geben Sie ConnectObject die Referenz auf das Objekt und den Namen, unter dem Events an Ihre eigenen Script-Prozeduren weitergeleitet werden sollen. In der Praxis ist ConnectObject allerdings sehr beschränkt. Es funktioniert nämlich nur mit ausgewählten Objekten, zum Beispiel selbstprogrammierten Visual Basic COM-Objekten.
3.4.3
DisconnectObject: Eventüberwachung ausknipsen
Mit DisconnectObject schalten Sie eine Eventüberwachung sofort aus. Ihr Script hört nicht länger auf die Events des Objekts. Wenn Sie zum Beispiel selbst den Internet Explorer via Quit schließen, wollen Sie meist nicht mehr ein onQuit-Event empfangen. Sie wissen nun ja selbst, daß der Internet Explorer schließen wird. In solch einem Fall verwenden Sie DisconnectObject, bevor Sie den IE schließen: ’ 3-13.VBS ' Internet Explorer öffnen und Events abhören set ie = WScript.CreateObject("InternetExplorer.Application", "event_") ie.Visible = true WScript.Sleep 20000 MsgBox "Lange genug gewartet – ich schließ das Ding jetzt selber.", _ vbSystemModal ' Eventüberwachung abschalten WScript.DisconnectObject ie ie.Quit WScript.Sleep 2000 sub event_onQuit
84
Kapitel 3: Die eingebauten WSH-Befehle: Wscript-Objekt
MsgBox "IE wird jetzt geschlossen!", vbSystemModal WScript.Quit end sub
Die Eventüberwachung kann auch vorübergehend abgeschaltet werden. Mit DisconnectObject schalten Sie sie ab, und mit ConnectObject wird die Überwachung wieder eingeschaltet. Allerdings ist die nachträgliche Event-Aktivierung beim InternetExplorer.Application-Objekt gar nicht möglich. ConnectObject funktioniert nur bei relativ wenigen COM-Objekten.
3.4.4
GetObject: In bestehende Objekte einklinken
GetObject hat zwei unterschiedliche Aufgaben:
Einerseits öffnen Sie damit Dokumente von Programmen, die automatisierbar sind. Dazu gehören zum Beispiel Microsoft Word-Dokumente.
Andererseits – und sicher wesentlich wichtiger – greifen Sie über GetObject auf latent vorhandene Systemdienste zu. Das kann ADSI (Active Directory Service Interface, Kapitel 10) ebenso sein wie WMI (Windows Management Instrumentation, Kapitel 11).
Wie Sie ein Winword-Dokument so öffnen, daß Ihr Script anschließend an die Methoden der zugrundeliegenden Winword-Applikation herankommt, zeigt das nächste Script: ’ 3-14.VBS ’ eine automatisierbare Datei ansprechen set document = WScript.GetObject("c:\test.doc") ’ Typ feststellen: MsgBox TypeName(document) ’ zur zugrundeliegenden Applikation umschalten: set app = document.Application ’ Anwendungsfenster sichtbar machen app.visible = true document.Activate
Es setzt voraus, daß es bei Ihnen eine Winword-Datei namens c:\test.doc gibt – passen Sie den Dateinamen gegebenenfalls an. GetObject liefert zunächst eine Instanz des Datei-Objekts, das bei Winword Document heißt. Über die Eigenschaft Application kann die zugrundeliegende Winword-Instanz angesprochen und mit Visible sichtbar gemacht werden. Winword läßt sich hervorragend automatisieren. Wieder liefert der Scripting Spy die nötigen Informationen: 1. Klicken Sie auf das Register Modul aussuchen, und doppelklicken Sie auf den Eintrag Word. Darunter finden Sie die Automationsobjekte, so auch Word.Document. Doppelklicken Sie darauf.
3.5
Scripts anhalten und sofort beenden
85
2. Nun analysiert der Scripting Spy intensiv die vielen tausend Funktionen von Winword und schaltet dann direkt um ins Document-Objekt. Hier sehen Sie nicht nur die Application-Eigenschaft, die das Script oben verwendet hat. Sie können auch zum Application-Object umschalten und entdecken dort neben der Visible-Eigenschaft viele weitere nützliche Details. Quit beendet zum Beispiel Winword. Allerdings funktioniert das nur, wenn auf Ihrem Computer die TypeLibrary von Winword installiert ist. In den einfachen Office-Versionen ist das nicht der Fall. Tip: Out-of-Process Server können nachtragend sein! Denken Sie daran: Echte Standalone-Programme wie Winword bleiben Ihnen erhalten, selbst wenn Ihr Script längst Feierabend gemacht hat. Das gilt für Winword ebenso wie für den Internet Explorer. Sorgen Sie also dafür, daß Sie die Programmfenster zuerst mit Visible=true sichtbar machen, oder beenden Sie die Programme zum Schluß Ihres Scripts mit Quit. Andernfalls kann es passieren, daß unsichtbare Fassungen der Programme im Speicher zurückbleiben und gelangweilt Däumchen drehen und Speicher verschwenden, bis Sie irgendwann das System neu booten. Alle Standalone-Programme listet der Scripting Spy übrigens über sein Registerblatt Programme auf.
3.5
Scripts anhalten und sofort beenden
Hin und wieder ist es nötig, daß das Script eine zeitlang wartet. Vielleicht möchten Sie bestimmte Routine-Checks nur alle 5 Minuten durchführen. Hier wäre es schlecht, eine Verzögerungsschleife einzubauen, nur um den WSH mit sinnloser Arbeit zu beschäftigen, bis es wieder Zeit für echte Aufgaben ist. Was Sie brauchen, ist eine Möglichkeit, den WSH für eine vorgegebene Zeit anzuhalten. Diese Möglichkeit existiert seit WSH 2.0. Zusätzlich haben Sie die Möglichkeit, eine Notbremse einzubauen, die das Script nach zu langer Laufzeit kurzerhand abbricht und so hilft, Endlosschleifen den Schrecken zu nehmen. Befehl
Beschreibung
Interactive Sleep
Unterdrückt bei der Einstellung False alle Dialogfenster Hält die Scriptausführung für einen festgelegten Zeitraum an, ohne daß in dieser Zeit CPU-Leistung benötigt würde Beendet ein Script sofort Beendet das Script spätestens nach der angegebenen Frist, legt also die maximale Ausführungszeit für ein Script fest.
Quit Timeout
Tab. 3.7: Script-Ausführung begrenzen oder pausieren
86 3.5.1
Kapitel 3: Die eingebauten WSH-Befehle: Wscript-Objekt
Interactive: Alle Benutzerausgaben unterdrücken
Interactive ist eine sonderbare Eigenschaft: Setzen Sie sie auf true, dann werden sämtliche Dialogfenster unterdrückt. Nicht umsonst ist Interactive undokumentiert, denn sinnvoll ist diese Möglichkeit nicht. Entweder sorgen Sie von vornherein dafür, daß Ihr Script ohne Benutzereingaben auskommt. Oder eben nicht. Einfach die Ausgabe-Dialoge zu unterschlagen kann jedenfalls unerwünschte Konsequenzen haben, die Sie besser nicht riskieren. Wscript.Interactive = false
3.5.2
Sleep: Script eine zeitlang anhalten
Sleep steht ab dem WSH 2.0 zur Verfügung und hält die Scriptausführung so lange an, wie Sie wollen. Solange das Script im Winterschlaf ist, verbraucht es keine Systemressourcen mehr. Damit ist Sleep ideal, wenn Sie nur von Zeit zu Zeit Checks durchführen wollen. Auch oben bei der Eventüberwachung hat es sich bewährt: Wscript.Sleep 10000
3.5.3
’ wartet 10 Sekunden
Quit: Script sofort beenden
Normalerweise endet ein Script, wenn entweder das Ende des Programms erreicht oder das Timeout abgelaufen ist. Ein Timeout ist als Vorgabe normalerweise nicht vorhanden. Wollen Sie Ihr Script dagegen sofort beenden, weil zum Beispiel ein Test ergeben hat, daß die Ausgangsvoraussetzungen für das Script überhaupt nicht erfüllt sind, dann rufen Sie Quit auf. Beispiele haben Sie bereits in den vorangegangenen Scripts gefunden: Wscript.Quit
3.5.4
' beendet die Ausführung sofort
Timeout: Script mit eingebauter Notbremse
Scripts laufen so lange, bis alle Aufgaben abgearbeitet sind – notfalls wochenlang. Solche fleißigen Scripts arbeiten aber meist gar nicht an sinnvollen Dingen, sondern sind in aller Regel aufgrund einer tückischen Endlosschleife in sinnlosen Ehrenrunden gefangen, aus denen sich das Script nicht mehr befreien kann. Das ist schlecht, weil so enorm viel Rechenzeit vom Script bzw. dem WSH konsumiert wird. Ihr System geht dauerhaft in die Knie. Hier hilft nur, mit dem Task Manager herrenlose Wscript.exe-Tasks zu beenden oder den Rechner neu zu starten. Damit Ihnen solche Dinge künftig weniger Kopfzerbrechen bereiten, können Sie auch vorbeugend etwas unternehmen. Rüsten Sie Ihr Script mit einem Timeout aus, dann beendet der WSH die Ausführung, wenn die Zeit um ist. Klar, daß Sie das Timeout eher großzügig wählen sollten, damit nicht bei langwierigen Aufgaben die Zeitkontrolle dazwischenhaut. ’ 3-15.VBS ' Timeout – Notbremse festlegen wscript.timeout = 5
3.5
Scripts anhalten und sofort beenden
87
for x= 1 to 10 MsgBox x Next
In diesem Beispiel wird die maximale Lebensdauer des Scripts auf 5 Sekunden begrenzt. Für die Praxis sicher viel zu kurz, doch schauen Sie mal, wie weit Sie sich in diesen 5 Sekunden durchklicken können! Spätestens nach der Timeout-Frist von 5 Sekunden ist das Script beendet – entweder, weil Sie zehnmal geklickt haben, oder aufgrund des Timeouts. Schlägt das Timeout zu, dann verschwinden sofort und ohne weitere Vorwarnungen alle Fenster, die das Script möglicherweise angezeigt hatte.
89
4
Zugriff auf das Dateisystem: Scripting.FileSystemObject
Ihr gesamtes Dateisystem wird durch das Scripting.FileSystemObject transparent: Dieses Objekt liefert alle Befehle, um in Ordner zu schauen, Dateien zu kopieren, zu löschen und neu anzulegen. Das Scripting.FileSystemObject ist Teil des WSH. Es wird auch von einigen anderen Komponenten wie zum Beispiel dem Internet Information Server und dem Personal Web Server auf dem System installiert. Tip: Details und Beispiele – hier werden Sie fündig Dieses Kapitel ist als Referenz und Hintergrundinformation gedacht. Die einzelnen Befehle werden kurz und knapp beschrieben. Wenn Sie Alltagsbeispiele und komplexere Anwendungen wünschen, dann schauen Sie bitte in den Vorgängerband »Franzis’: Professional Series Scripting Host Praxisbuch«. Dem Thema Dateizugriff ist dort breiter Raum gewidmet.
4.1
Das Objekt-Modell kennenlernen
Das Scripting.FileSystemObject besteht neben der Kernkomponente aus sieben weiteren Objekten, die das folgende Diagramm aufführt. Scripts rufen immer zuerst das FileSystemObject zu Hilfe und können danach mit dessen Funktionen die übrigen Objekte erreichen. Im wesentlichen teilen sich diese Objekte in drei Bereiche:
Drives ist die Aufzählung aller Laufwerke, und Drive ist ein bestimmtes Laufwerk.
Folders ist die Aufzählung aller Ordner innerhalb eines Ordners, und Folder ist ein bestimmter Ordner.
Files ist die Aufzählung aller Dateien in einem Ordner, und File ist eine bestimmte Datei.
Daneben gibt es noch das TextStreamObject. Das entspricht einer geöffneten Datei, in die geschrieben oder aus der gelesen werden kann.
90
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject
Bild 4.1: Die Objekthierarchie des Scripting.FileSystemObject
4.2
Allgemeine Befehle des Scripting.FileSystemObject
Neben den eigentlichen Funktionen, um Laufwerke, Ordner und Dateien zu managen, beinhaltet das Objekt eine ganze Reihe nützlicher Service-Funktionen: Funktionen
Beschreibung
BuildPath CopyFile CopyFolder DeleteFile DeleteFolder DriveExists FileExists FolderExists GetAbsolutePathName GetBaseName GetDriveName GetExtensionName GetFileName GetFileVersion GetParentFolderName GetTempName MoveFile MoveFolder
Erstellt aus Pfad und Dateiname einen gültigen Pfadnamen für die Datei Kopiert eine Datei Kopiert einen Ordner Löscht eine Datei Löscht einen Ordner Prüft, ob ein Laufwerk existiert Prüft, ob eine Datei existiert Prüft, ob ein Ordner existiert Ermittelt den reinen Ordnerpfadnamen aus einem Dateipfad Liefert nur den Dateinamen ohne Ordnerpfad und Extension Liefert den Namen eines Laufwerks Liefert die Dateiextension eines Pfadnamens Liefert den Dateinamen (WSH 2.0) Ermittelt die Version einer EXE- oder DLL-Datei Ermittelt den Namen des übergeordneten Ordners Liefert einen zufällig generierten Dateinamen Verschiebt eine Datei Verschiebt einen Ordner
Tab. 4.1: Wichtige Befehle des Scripting.FileSystemObject
4.2
4.2.1
Allgemeine Befehle des Scripting.FileSystemObject
91
BuildPath
Function BuildPath(ByVal Path As String, ByVal Name As String) As String
Erstellt einen Pfad aus der Ordner- und der Datei-Angabe: ’ 4-1.vbs set fs = CreateObject("Scripting.FileSystemObject") pfad = InputBox("Bitte Pfad angeben!",,"c:\test") datei = InputBox("Bitte Datei angeben!",,"willi.txt") MsgBox fs.BuildPath(pfad, datei)
4.2.2
CopyFile
Sub CopyFile(ByVal Source As String, ByVal Destination As String, [ByVal OverWriteFiles As BooleanWahr])
Kopiert eine Datei mit allen Attributen und überschreibt wahlweise eine schon vorhandene Datei. ’ 4-2.vbs set fs = CreateObject("Scripting.FileSystemObject") original = "C:\autoexec.bat" ziel = "C:\test.txt" fs.CopyFile original, ziel, true MsgBox "kopiert!"
Dieses Script kopiert die Datei AUTOEXEC.BAT und überschreibt dabei TEST.TXT, falls die Datei schon vorhanden ist. Ersetzen Sie true durch false, dann wird nicht überschrieben. CopyFile kann keine Dateien überschreiben, wenn das System-Attribut gesetzt ist. Solche Dateien müssen zuerst explizit mit DeleteFile gelöscht werden.
4.2.3
CopyFolder
Sub CopyFolder(ByVal Source As String, ByVal Destination As String, [ByVal OverWriteFiles As BooleanWahr])
Wie CopyFile, nur werden hier Ordner kopiert.
4.2.4
DeleteFile
Sub DeleteFile(ByVal FileSpec As String, [ByVal Force As BooleanFalsch])
Wie CopyFile, nur werden hier Dateien gelöscht. DeleteFile kann keine Dateien löschen, bei denen das System- oder Schreibgeschützt-Attribut gesetzt ist, es sei denn, Sie verwenden die Macht. Die Macht aktivieren Sie mit dem zweiten optionalen Argument. Setzen Sie es auf true, dann wird auf jeden Fall gelöscht.
92 4.2.5
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject
DeleteFolder
Sub DeleteFolder(ByVal FolderSpec As String, [ByVal Force As BooleanFalsch])
Wie CopyFolder, nur werden Ordner gelöscht.
4.2.6
DriveExists
Function DriveExists(ByVal DriveSpec As String) As Boolean
Prüft, ob ein Laufwerk existiert: ’ 4-3.vbs set fs = CreateObject("Scripting.FileSystemObject") if fs.DriveExists("K:\") then MsgBox "Laufwerk K: existiert." else MsgBox "Laufwerk K: existiert nicht." end if
4.2.7
FileExists
Function FileExists(ByVal FileSpec As String) As Boolean
Wie DriveExists, nur wird hier auf die Existenz einer Datei geprüft. Geben Sie den vollen Pfadnamen an.
4.2.8
FolderExists
Function FolderExists(ByVal FolderSpec As String) As Boolean
Wie DriveExists, nur wird hier geprüft, ob ein Ordner existiert.
4.2.9
GetAbsolutePathName
Function GetAbsolutePathName(ByVal Path As String) As String
Fügt den aktuellen Pfadnamen an einen Dateinamen an. Der aktuelle Pfadname ist der Name des aktuell im Explorer geöffneten Ordners. In der Regel ist dies der Pfadname, in dem Ihr Script ausgeführt wird. ’ 4-4.vbs set fs = CreateObject("Scripting.FileSystemObject") pfad = InputBox("Geben Sie einen Dateinamen ein!",, _ "willi.txt") MsgBox fs.GetAbsolutePathName(pfad)
4.2
Allgemeine Befehle des Scripting.FileSystemObject
4.2.10 GetBaseName Function GetBaseName(ByVal Path As String) As String
Entfernt den Pfad- und Extensionsanteil eines Pfads und liefert den reinen Dateinamen zurück: ’ 4-5.vbs set fs = CreateObject("Scripting.FileSystemObject") pfad = InputBox("Geben Sie einen Dateinamen ein!",, _ "c:\test\willi.txt") MsgBox fs.GetBaseName(pfad)
4.2.11 GetDriveName Function GetDriveName(ByVal Path As String) As String
Liefert den Laufwerksbuchstaben aus einem komplexen Pfad zurück: ’ 4-6.vbs set fs = CreateObject("Scripting.FileSystemObject") pfad = InputBox("Geben Sie einen Dateinamen ein!",, _ "c:\test\willi.txt") MsgBox fs.GetDriveName(pfad)
4.2.12 GetExtensionName Function GetExtensionName(ByVal Path As String) As String
Liefert die Dateiextension eines Pfadnamens zurück: ’ 4-7.vbs set fs = CreateObject("Scripting.FileSystemObject") pfad = InputBox("Geben Sie einen Dateinamen ein!",, _ "c:\test\willi.txt") MsgBox fs.GetExtensionName(pfad)
4.2.13 GetFileName Function GetFileName(ByVal Path As String) As String
Liefert den Dateinamen einschließlich Extension zurück: ’ 4-8.vbs set fs = CreateObject("Scripting.FileSystemObject") pfad = InputBox("Geben Sie einen Dateinamen ein!",, _
93
94
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject "c:\test\willi.txt")
MsgBox fs.GetFileName(pfad)
4.2.14 GetFileVersion Function GetFileVersion(ByVal FileName As String) As String
Liefert die Version einer DLL- oder EXE-Datei zurück. Ist keine Versionsinformation in der Datei enthalten, dann kommt es bei älteren WSH-Versionen zu einem Fehler. ’ 4-9.vbs set fs = CreateObject("Scripting.FileSystemObject") windir = fs.GetSpecialFolder(0).Path file = windir & "\explorer.exe" MsgBox fs.GetFileVersion(file)
4.2.15 GetParentFolderName Function GetParentFolderName(ByVal Path As String) As String
Liefert den Ordnernamen zurück, in dem eine Datei liegt: ’ 4-10.vbs set fs = CreateObject("Scripting.FileSystemObject") pfad = InputBox("Geben Sie einen Dateinamen ein!",, _ "c:\test\willi.txt") MsgBox fs.GetParentFolderName(pfad)
4.2.16 GetTempName Function GetTempName As String
Generiert einen zufälligen Dateinamen: ’ 4-11.vbs set fs = CreateObject("Scripting.FileSystemObject") for x = 1 to 10 list = list & fs.GetTempName & vbCr next MsgBox list
4.3
Laufwerke managen
95
4.2.17 MoveFile Sub MoveFile(ByVal Source As String, ByVal Destination As String)
Wie CopyFile, nur wird die Datei verschoben.
4.2.18 MoveFolder Sub MoveFolder(ByVal Source As String, ByVal Destination As String)
Wie CopyFolder, nur wird der Ordner verschoben.
4.3
Laufwerke managen
Das Drive-Objekt repräsentiert ein bestimmtes Laufwerk. Wenn Sie also Details über ein Laufwerk erfahren wollen, dann brauchen Sie das Drive-Objekt des Laufwerks. Folgende Möglichkeiten haben Sie, um ein Drive-Objekt zu erhalten:
4.3.1
GetDrive – spezifisches Laufwerk heraussuchen
Mit GetDrive picken Sie sich ein Laufwerk heraus, indem Sie den gewünschten Laufwerksbuchstaben angeben: set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drive = FileSystemObject.GetDrive("C:\")
4.3.2
Drives – alle Laufwerke, die es gibt
Drives liefert ein Drives-Objekt, die Kollektion aller Drive-Objekte, die es auf Ihrem Computer gibt. Über for each...next können die einzelnen Drive-Objekte ausgelesen werden. ’ 4-12.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drives = FileSystemObject.Drives for each drive in drives MsgBox drive next
4.3.3
Drive – das Laufwerk eines Ordners
Drive ist eine Eigenschaft des Folder-Objekts und liefert das Drive-Objekt des Laufwerks zurück, auf dem der Ordner gespeichert ist.
96
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject
set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\WINDOWS") set drive = Folder.Drive
4.4
Methoden und Eigenschaften des Drive-Objekts
Haben Sie sich auf eine der oben genannten Arten ein Drive-Objekt verschafft, dann können Sie die Detailinformationen des Laufwerks auslesen: Eigenschaft
Bedeutung
AvailableSpace FreeSpace DriveLetter DriveType FileSystem IsReady Path RootFolder SerialNumber ShareName TotalSize VolumeName
Freier Speicherplatz für den gerade angemeldeten Benutzer Freier Speicherplatz insgesamt auf dem Laufwerk Laufwerksbuchstabe Laufwerkstyp Art des Dateisystems Wahr, wenn das Laufwerk einen Datenträger enthält Pfadname Referenz auf das Folder-Objekt des Stammordners Seriennummer des Datenträgers Freigabename des Datenträgers Gesamtgröße des Datenträgers Datenträgerbezeichnung
Tab. 4.2: Befehle und Infos des Drive-Object
Tip: Vorsicht – 2 GB Bug! In den älteren Versionen des WSH – speziell auf Rechnern, die nicht Windows 2000 verwenden – sind die Größenangaben auf 2 GB begrenzt. Ist ein Laufwerk größer als 2 GB, dann werden die darüber hinausgehenden Speichermengen unterschlagen. Eine Festplatte ist aus Sicht des alten WSHs also immer maximal 2 GB groß und kann maximal 2 GB freien Speicher enthalten. Das führt zu dem kuriosen Resultat, daß ein 4 GB großes Laufwerk mit 2 GB Daten zu 100% unbelegt erscheint, weil sowohl seine Maximalgröße als auch der freie Speicherplatz mit 2 GB angegeben werden. Eine Lösung dieses Problems finden Sie in Kapitel 8.5.
4.4.1
AvailableSpace
Property AvailableSpace ’ 4-13.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drive = FileSystemObject.GetDrive("C:\") MsgBox Drive.AvailableSpace
4.4
4.4.2
Methoden und Eigenschaften des Drive-Objekts
DriveLetter
Property DriveLetter As String ’ 4-14.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drives = FileSystemObject.Drives for each drive in drives MsgBox drive.DriveLetter Next
4.4.3
DriveType
Property DriveType As DriveTypeConst
Konstante
Beschreibung
Const CDRom = 4 Const Fixed = 2 Const RamDisk = 5 Const Remote = 3 Const Removable = 1 Const Unknown = 0
CD-ROM Laufwerk Festplatte RAM-Disk Netzlaufwerk Wechselplattenlaufwerk Unbekannter Typ
Tab. 4.3: Laufwerkstypen und deren Codes ’ 4-15.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drives = FileSystemObject.Drives for each drive in drives MsgBox drive.DriveType Next
4.4.4
FileSystem
Property FileSystem As String ’ 4-16.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drives = FileSystemObject.Drives for each drive in drives if drive.isReady then MsgBox drive.DriveLetter & " verwendet " _ & Drive.FileSystem end if Next
97
98 4.4.5
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject
FreeSpace
Property FreeSpace ’ 4-17.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drive = FileSystemObject.GetDrive("C:\") MsgBox Drive.FreeSpace
4.4.6
IsReady
Property IsReady As Boolean ’ 4-18.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drives = FileSystemObject.Drives for each drive in drives MsgBox drive.DriveLetter & " ist bereit? " & Drive.IsReady Next
4.4.7
Path
Property Path As String ’ 4-19.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drives = FileSystemObject.Drives for each drive in drives MsgBox Drive.Path Next
4.4.8
RootFolder
Property RootFolder As IFolder ’ 4-20.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drive = FileSystemObject.GetDrive("C:\") set folder = Drive.RootFolder MsgBox TypeName(folder)
4.4.9
SerialNumber
Property SerialNumber As Long
4.5
Ordner managen
99
’ 4-21.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drive = FileSystemObject.GetDrive("C:\") MsgBox Drive.SerialNumber
4.4.10 ShareName Property ShareName As String ’ 4-22.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drive = FileSystemObject.GetDrive("C:\") MsgBox Drive.ShareName
4.4.11 TotalSize Property TotalSize ’ 4-23.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drive = FileSystemObject.GetDrive("C:\") MsgBox Drive.TotalSize
4.4.12 VolumeName Property VolumeName As String ’ 4-24.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drive = FileSystemObject.GetDrive("C:\") newname = InputBox("Name des Laufwerks?",, Drive.VolumeName) drive.VolumeName = newname
4.5
Ordner managen
Ordner sind ganz ähnlich organisiert wie Laufwerke. Wieder gibt es eine Collection in Form des Folders-Objekts und eigene separate Ordner in Form eines Folder-Objekts. Das folgende Diagramm veranschaulicht die verwandschaftlichen Verhältnisse:
100
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject
Bild 4.2: Der Zusammenhang zwischen Ordnern und Inhalt
Über Drives bekommen Sie ein Drives-Objekt, die Kollektion aller Laufwerke. Mit for each...next können Sie daraus Drive-Objekte abzapfen oder ein bestimmtes Drive-Objekt direkt via GetDrive ansteuern. Drive-Objekte wiederum liefern via RootFolder ein Folder-Objekt, das auch direkt über GetFolder erreichbar ist. Das Folder-Objekt liefert via Subfolders ein Folders-Objekt, in dem alle Unterordner des Ordners zusammengefaßt sind. Mit for each...next entnehmen Sie daraus einzelne Folder-Objekte, die wiederum auch direkt über GetFolder zur Verfügung stehen. Folder-Objekte ihrerseits bieten mit ihrer Drive-Eigenschaft immer eine Referenz zum zugrundeliegenden Drive-Objekt.
Bild 4.3: Der Zusammenhang zwischen Laufwerk und Ordnern
Die einzelnen Folder-Objekte hängen ihrerseits zusammen, so daß Sie sich sowohl tiefer in die Verzeichnisbäume bewegen als auch wieder aus ihnen herauskommen können. Die Unterordner eines Ordners liefert Subfolders. Über die Folders-Collection erreichen Sie so jeden Unterordner. Vom Unterordner kommen Sie über ParentFolder wieder eine Ebene höher, und mit isRootFolder können Sie jederzeit prüfen, ob Sie die »Oberfläche« wieder erreicht haben und beim Wurzelverzeichnis des Laufwerks angelangt sind. Wenn Sie sich mit einem Ordner oder seinem Inhalt beschäftigen wollen, dann brauchen Sie ein Folder-Objekt. Das bekommen Sie so:
4.5
4.5.1
Ordner managen
CreateFolder
’ 4-25.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.CreateFolder("C:\MEINNEUERORDNER")
4.5.2
GetFolder
’ 4-26.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\")
4.5.3
GetSpecialFolder
’ 4-27.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetSpecialFolder(2) MsgBox "Windows-Ordner: " & folder.path
Systemordner-Konstante
Beschreibung
Const SystemFolder = 1 Const TemporaryFolder = 2 Const WindowsFolder = 0
Systemordner von Windows Temp-Ordner für zwischengespeicherte Daten Windows-Ordner
Tab. 4.4: Spezialordner und deren Codezahlen
4.5.4
RootFolder
’ 4-28.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set drive = FileSystemObject.GetDrive("C:\") set folder = Drive.RootFolder
4.5.5
ParentFolder
’ 4-29.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST") set folder = file.ParentFolder
101
102
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject
4.5.6
Subfolders
’ 4-30.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\") set subfolder = folder.subfolders for each subf in subfolder MsgBox TypeName(subf) & " Name: " & subf.name next
4.6
Eigenschaften des Folder-Objekts
Sobald Sie sich ein Folder-Objekt verschafft haben, können Sie die folgenden Eigenschaften abfragen und ändern: Eigenschaft
Beschreibung
SubFolders Size ShortPath ShortName Path ParentFolder Name IsRootFolder Files
Liefert ein Folders-Objekt zurück, das die Folder-Objekte aller Unterordner enthält Liefert die Gesamtgröße des Ordners einschließlich aller Unterordner zurück 8.3-Pfadname des Ordners 8.3-Name des Ordners Pfadname des Ordners Folder-Objekt des übergeordneten Ordners Name des Ordners True, wenn dieser Ordner die Wurzel eines Laufwerks repräsentiert Liefert ein Files-Objekt zurück, das die File-Objekte aller Dateien enthält, die in diesem Ordner gespeichert sind Liefert ein Drive-Objekt des zugrundeliegenden Laufwerks zurück Datum der letzten Änderung an diesem Ordner Datum des letzten Zugriffs auf diesen Ordner Erstellungsdatum des Ordners Dateiattribute des Ordners
Drive DateLastModified DateLastAccessed DateCreated Attributes
Tab. 4.5: Eigenschaften eines Folder-Objekts
Das Folder-Objekt beinhaltet eine Reihe von Funktionen und Prozeduren: Methode
Beschreibung
CreateTextFile Copy Delete Move
Legt im Ordner eine neue Datei an und liefert ein TextStreamObject zurück Kopiert den Ordner Löscht den Ordner Verschiebt den Ordner
Tab. 4.6: Befehle eines Folder-Objekts
4.6
4.6.1
Eigenschaften des Folder-Objekts
103
Attributes
Property Attributes As FileAttribute ’ 4-31.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\WINDOWS") MsgBox Folder.Attributes
Die Attribute sind als Bitmaske gespeichert. Hier die Werte: Wert
Attribut
1 2 4 8 16 32 64 1024 2048
Schreibgeschützt Versteckt System Laufwerk Ordner Archiv Verknüpfung Alias Komprimiert (Windows NT)
Tab. 4.7: Dateiattribute und deren Codezahlen
Wollen Sie zum Beispiel prüfen, ob das Versteckt-Attribut der Datei C:\AUTOEXEC.BAT gesetzt ist, dann machen Sie das so: ’ 4-32.vbs set fs = CreateObject("Scripting.FileSystemObject") datei = "C:\AUTOEXEC.BAT" set file = fs.GetFile(datei) attribute = file.Attributes if (attribute and 2)<>0 then MsgBox "Die Datei ist versteckt!" else MsgBox "Die Datei ist NICHT versteckt!" end if
Auch das Setzen von Attributen ist nicht besonders schwierig. Sie müssen nur darauf achten, keine schreibgeschützten Attribute zu setzen. Das würde zu einem Fehler führen. Wollen Sie also scriptgesteuert das Versteckt-Attribut der Datei AUTOEXEC.BAT setzen, dann könnte dies ein Weg sein: ’ 4-33.vbs set fs = CreateObject("Scripting.FileSystemObject") datei = "C:\AUTOEXEC.BAT"
104
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject
set file = fs.GetFile(datei) attribute = file.Attributes file.Attributes = attribute or 2 and not 65497 MsgBox "AUTOEXEC.BAT ist jetzt auf jeden Fall versteckt!"
Dieses Script setzt das Versteckt-Attribut. Alle schreibgeschützten Bits werden mit and not 65492 ausgeblendet. Prüfen Sie den Erfolg Ihrer Aktion einfach mit Script 4-32.vbs, oder noch einfacher: Klicken Sie die Datei im Explorer mit der rechten Maustaste an, und wählen Sie Eigenschaften. Schauen Sie dann die Attribute direkt an. Und wie löscht man Attribute? Das nächste Script entfernt das Versteckt-Attribut wieder: ’ 4-34.vbs set fs = CreateObject("Scripting.FileSystemObject") datei = "C:\AUTOEXEC.BAT" set file = fs.GetFile(datei) attribute = file.Attributes file.Attributes = attribute and not 2 and not 65497 MsgBox "AUTOEXEC.BAT ist jetzt auf jeden Fall NICHT versteckt!"
4.6.2
Copy
Sub Copy(ByVal Destination As String, [ByVal OverWriteFiles As BooleanWahr]) ’ 4-35.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\TEST") Call Folder.Copy("C:\BACKUP", true)
4.6.3
CreateTextFile
Function CreateTextFile(ByVal FileName As String, [ByVal Overwrite As BooleanWahr], [ByVal Unicode As BooleanFalsch]) As ITextStream ’ 4-36.vbs set fs = CreateObject("Scripting.FileSystemObject") set obj = fs.CreateTextFile("C:\test.txt", true) obj.WriteLine "Hallo" obj.close
4.6
4.6.4
Eigenschaften des Folder-Objekts
105
DateCreated
Property DateCreated As Date ’ 4-37.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\WINDOWS") MsgBox Folder.DateCreated
Aufpassen: Alle Datumsfunktionen sind fehleranfällig. Eine Datei oder ein Ordner muß nämlich nicht über die gewünschte Information verfügen. Ist gar kein Erstellungsdatum eingetragen, dann kassiert Ihr Script einen Fehler. Schauen Sie sich die Datei oder den Ordner einfach per Rechtsklick und Eigenschaften an. Sie werden feststellen, daß die Datumsangaben häufig fehlen.
Bild 4.4: In diesem Ordner wurde kein Erstell-Datum gespeichert
Sie können das Problem relativ leicht umgehen, indem Sie auf Fehler prüfen: ’ 4-38.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\WINDOWS") on error resume next datum = Folder.DateCreated if err.number<>0 then datum = "(unbekannt)" on error goto 0 MsgBox datum
106 4.6.5
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject
DateLastAccessed
Property DateLastAccessed As Date ’ 4-39.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\WINDOWS") MsgBox Folder.DateLastAccessed
4.6.6
DateLastModified
Property DateLastModified As Date ’ 4-40.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\WINDOWS") MsgBox Folder.DateLastModified
4.6.7
Delete
Sub Delete([ByVal Force As BooleanFalsch]) ’ 4-41.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\TEST") Call Folder.Delete(true)
4.6.8
Drive
Property Drive As IDrive ’ 4-42.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\WINDOWS") set obj = Folder.Drive MsgBox obj.DriveLetter
4.6.9
Files
Property Files As IFileCollection ’ 4-43.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\WINDOWS") set obj = Folder.Files
4.6
Eigenschaften des Folder-Objekts
for each file in obj list = list & file.name & vbCr next MsgBox list
4.6.10 IsRootFolder Property IsRootFolder As Boolean ’ 4-44.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\") MsgBox Folder.IsRootFolder
4.6.11 Move Sub Move(ByVal Destination As String) ’ 4-45.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\TEST") Call Folder.Move("C:\TESTNEU")
4.6.12 Name Property Name As String ’ 4-46.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\WINDOWS") MsgBox Folder.Name
4.6.13 ParentFolder Property ParentFolder As IFolder ’ 4-47.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\WINDOWS") set obj = Folder.ParentFolder MsgBox obj.Path
107
108
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject
4.6.14 Path Property Path As String ’ 4-48.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\WINDOWS") MsgBox Folder.Path
4.6.15 ShortName Property ShortName As String ’ 4-49.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\LANGERNAME") MsgBox Folder.ShortName
4.6.16 ShortPath Property ShortPath As String ’ 4-50.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\LANGERNAME") MsgBox Folder.ShortPath
4.6.17 Size Property Size ’ 4-51.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetSpecialFolder(0) MsgBox Folder.Size
Die Size-Methode berechnet den gesamten Inhalt eines Ordners einschließlich aller Unterordner. Je nach der Datenmenge kann es einige Sekunden dauern, bis die Gesamtgröße berechnet ist.
4.6.18 SubFolders Property SubFolders As IFolderCollection ’ 4-52.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject")
4.7
Dateien managen
109
set folder = FileSystemObject.GetSpecialFolder(0) set obj = Folder.SubFolders for each subfolder in obj list = list & subfolder.name & vbCr next MsgBox list
4.6.19 Type Property Type As String ’ 4-53.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\WINDOWS") MsgBox Folder.Type
4.7
Dateien managen
Auch Dateien sind in analogem Schema organisiert. Das File-Objekt entspricht einer einzelnen Datei, während das Files-Objekt eine Reihe von Dateien als Collection ihrer File-Objekte repräsentiert. Wenn Sie die Eigenschaften einer Datei untersuchen oder Dateien verschieben und kopieren wollen, dann brauchen Sie ein File-Objekt. So gelangt es in Ihre Hände:
4.7.1
GetFile
set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT")
4.7.2
Files
’ 4-54.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set folder = FileSystemObject.GetFolder("C:\WINDOWS") set files = Folder.Files for each file in files list = list & file.name next MsgBox list
110 4.8
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject
Eigenschaften und Methoden des File-Objekts
Haben Sie sich ein File-Objekt verschafft, dann können Sie die folgenden Eigenschaften und Methoden nutzen: Eigenschaften/Methoden
Beschreibung
Attributes Copy DateCreated DateLastAccessed DateLastModified Delete Drive Move Name OpenAsTextStream ParentFolder Path ShortName ShortPath Size Type
Dateiattribute Datei kopieren Erstellungsdatum der Datei Letzter Zugriff auf die Datei Datum der letzten Dateiänderung Datei löschen Liefert Drive-Objekt des Laufwerks, auf dem die Datei liegt Datei verschieben Name der Datei Dateiinhalt bearbeiten; liefert ein TextstreamObject zurück Liefert Folder-Objekt des Ordners zurück, in dem die Datei liegt Pfadname der Datei 8.3-Name der Datei 8.3-Pfadname der Datei Größe der Datei in Bytes Typ der Datei
Tab. 4.8: Eigenschaften und Befehle eines File-Objekts
4.8.1
Attributes
Property Attributes As FileAttribute ’ 4-55.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT") MsgBox File.Attributes
Wie Sie die Zahlenwerte der Attributes-Eigenschaft in verständliche Dateiattribute umwandeln und selbst die Attribute ändern, habe ich Ihnen bereits oben bei der Attributes-Eigenschaft des FolderObjekts gezeigt.
4.8.2
Copy
Sub Copy(ByVal Destination As String, [ByVal OverWriteFiles As BooleanWahr]) ’ 4-56.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT") Call File.Copy("C:\TEST2.TXT", true)
4.8
4.8.3
Eigenschaften und Methoden des File-Objekts
111
DateCreated
Property DateCreated As Date ’ 4-57.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT") MsgBox File.DateCreated
Wie schon beim Folder-Objekt und seinen Datumsfunktionen gilt auch beim File-Objekt: Ist keine Datumsinformation protokolliert worden, dann können die Datumsinformationen auch nicht abgefragt werden. Wer es dennoch versucht, kassiert einen Fehler. Bei der DateCreated-Eigenschaft des Folder-Objekts hatte ich Ihnen gezeigt, wie einfach Sie solche Fehler abfangen.
4.8.4
DateLastAccessed
Property DateLastAccessed As Date ’ 4-58.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT") MsgBox File.DateLastAccessed
4.8.5
DateLastModified
Property DateLastModified As Date ’ 4-59.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT") MsgBox File.DateLastModified
4.8.6
Delete
Sub Delete([ByVal Force As BooleanFalsch]) ’ 4-60.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT") Call File.Delete(true)
112 4.8.7
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject
Drive
Property Drive As IDrive ’ 4-61.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT") set obj = File.Drive MsgBox obj.DriveLetter
4.8.8
Move
Sub Move(ByVal Destination As String) ’ 4-62.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT") Call File.Move("C:\TEST2.TXT")
4.8.9
Name
Property Name As String ’ 4-63.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT") MsgBox File.Name
4.8.10 OpenAsTextStream Function OpenAsTextStream([ByVal IOMode As IOModeForReading], [ByVal Format As TristateTristateFalse]) As ITextStream ’ 4-64.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT") set obj = File.OpenAsTextStream do until obj.atEndOfStream MsgBox obj.ReadLine Loop Obj.close
4.8
Eigenschaften und Methoden des File-Objekts
4.8.11 ParentFolder Property ParentFolder As IFolder ’ 4-65.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT") set obj = File.ParentFolder MsgBox obj.Path
4.8.12 Path Property Path As String ’ 4-66.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT") MsgBox File.Path
4.8.13 ShortName Property ShortName As String ’ 4-67.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\LANGERNAME.TXT") MsgBox File.ShortName
4.8.14 ShortPath Property ShortPath As String ’ 4-68.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\LANGERNAME.TXT") MsgBox File.ShortPath
4.8.15 Size Property Size ’ 4-69.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT") MsgBox File.Size
113
114
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject
4.8.16 Type Property Type As String ’ 4-70.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\TEST.TXT") MsgBox File.Type
4.9
Dateien neu anlegen, auslesen und verändern
Bislang haben Sie Ihre gespeicherten Daten nur mit Hilfe der Container Laufwerk, Ordner und Datei gemanagt. Sicher wollen Sie aber irgendwann auch direkt an die Daten herankommen, die in einer Datei gespeichert sind. Ebenso wichtig: Ihr Script soll die Möglichkeit erhalten, eigene Daten in einer Datei zu speichern.
Bild 4.5: Zugriff auf den Inhalt einer Datei
Zuständig hierfür ist das Textstream-Objekt. Dieses Objekt repräsentiert eine geöffnete Datei, aus der gelesen und in die geschrieben werden kann. Allerdings unterstützt VBScript keine Binärdaten, sondern nur Strings. Deshalb sind nur Textdateien bequem über das TextStreamObject verwaltbar. Binärdateien können zwar ebenfalls gelesen und geschrieben werden, aber dann muß zeichenweise gelesen werden.
4.9
Dateien neu anlegen, auslesen und verändern
115
Das TextStreamObject ist das unterste Objekt der Hierarchie, hier sind die realen Daten gespeichert. Das TextStreamObject kann entweder direkt über OpenTextFile oder ab der Ordnerebene vom Folder-Objekt oder File-Objekt aus angelegt werden. Das TextStreamObject spielt aber nicht nur bei echten Dateien eine Rolle. Es ist auch das universelle Objekt, mit dem Daten in den DOS-Stream hineingeschrieben und daraus gelesen werden. Der WSH tut also im Falle von DOS-Fenstern einfach so, als handele es sich dabei um eine Textdatei, aus der gelesen und in die geschrieben werden kann. Sie erhalten deshalb auch ein TextStreamObject über die Methode GetStandardStream sowie über die WSH-eigenen Methoden StdIn und StdOut (siehe Kapitel 3.3). Wichtig ist, daß alle drei Methoden einen Fehler liefern, wenn gar kein DOS-Fenster vorhanden ist. Ihr Script muß deshalb mit CSCRIPT.EXE gestartet werden, bevor Sie DOS-Streams einsetzen können. Für normale Dateioperationen ist es hingegen völlig egal, ob Ihr Script von CSCRIPT.EXE oder WSCRIPT.EXE ausgeführt wird. Wenn Sie den Inhalt einer Datei lesen oder ihn verändern wollen oder wenn Sie eine ganz neue Datei anlegen möchten, dann brauchen Sie ein TextStreamObject. So bekommen Sie es:
4.9.1
CreateTextFile
set textstream = FileSystemObject.CreateTextFile(ByVal FileName As String, [ByVal Overwrite As BooleanWahr], [ByVal Unicode As BooleanFalsch])
Setzen Sie als zweiten Parameter immer true, wenn Sie sicher gehen wollen, daß die Datei auch wirklich angelegt wird. Dabei werden gleichnamige schon existierende Dateien überschrieben. set fs = CreateObject("Scripting.FileSystemObject") set datei = fs.CreateTextFile("C:\TEST.TXT", true)
4.9.2
OpenTextFile
set textstream = FileSystemObject.OpenTextFile(ByVal FileName As String, [ByVal IOMode As IOModeForReading], [ByVal Create As BooleanFalsch], [ByVal Format As TristateTristateFalse]) set FileSystemObject = CreateObject("Scripting.FileSystemObject") set textstream = FileSystemObject.OpenTextFile("c:\test.txt", 1, true)
Besonders wichtig ist hier der Modus, in dem Sie eine Datei öffnen. Der Modus wird mit IOMode festgelegt: IOMode
Bedeutung
1 2 8
Datei zum Lesen öffnen Datei zum Schreiben öffnen Datei zum Lesen und Schreiben öffnen, neue Daten anhängen (Append)
Tab. 4.9: Zugriffsarten auf den Datei-Inhalt
116 4.9.3
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject
OpenAsTextStream
set textstream = File.OpenAsTextStream([ByVal IOMode As IOModeForReading], [ByVal Format As TristateTristateFalse]) set FileSystemObject = CreateObject("Scripting.FileSystemObject") set file = FileSystemObject.GetFile("C:\test.txt") set textstream = File.OpenAsTextStream(1)
4.10
Eigenschaften und Methoden von TextStreamObject
Sobald Sie ein TextStreamObject in der Hand haben, können Sie damit den Dateiinhalt auslesen oder ihn neu schreiben. Ob das TextStreamObject für Leseoperationen oder für Schreiboperationen geöffnet ist, hängt von den Optionen ab, die Sie angegeben haben, als Sie das TextStreamObject erstellt haben (siehe oben). Eigenschaft/Methode
Beschreibung
AtEndOfLine AtEndOfStream Close Column Line Read ReadAll ReadLine Skip SkipLine Write WriteBlankLines WriteLine
True, wenn ein Zeilenende erreicht ist True, wenn das Dateiende erreicht ist Schließt die Datei Gibt die Spaltenzahl an (Zeichen seit dem letzten Wagenrücklauf) Gibt die Zeilenzahl an (Anzahl der bisherigen Wagenrückläufe) Liest eine festgelegte Anzahl von Zeichen Liest die gesamte Datei Liest genau eine Zeile Überspringt eine festgelegte Anzahl Zeichen Überspringt genau eine Zeile Schreibt Text Schreibt eine leere Zeile Schreibt Text und fügt einen Wagenrücklauf an (vbCrLf).
Tab. 4.10: Eigenschaften und Befehle eines TextStream-Objekts
4.10.1 AtEndOfLine Property AtEndOfLine As Boolean ’ 4-71.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set textstream = FileSystemObject.OpenTextFile("C:\test.txt", 1) do until TextStream.AtEndOfLine MsgBox TextStream.ReadLine Loop Textstream.close
4.10
Eigenschaften und Methoden von TextStreamObject
4.10.2 AtEndOfStream Property AtEndOfStream As Boolean
True, wenn das Ende der Datei erreicht wurde.
4.10.3 Close Sub Close
Schließt ein TextStream-Objekt.
4.10.4 Column Property Column As Long
Liefert die aktuelle Spaltenposition in einer geöffneten Textdatei.
4.10.5 Line Property Line As Long
Liefert die aktuelle Zeilenposition in einer geöffneten Textdatei.
4.10.6 Read Function Read(ByVal Characters As Long) As String
Liest eine beliebige Anzahl von Zeichen aus einer geöffneten Textdatei.
4.10.7 ReadAll Function ReadAll As String
Liest den gesamten Inhalt der geöffneten Textdatei.
4.10.8 ReadLine Function ReadLine As String
Liest genau eine Zeile aus einer geöffneten Textdatei.
117
118
Kapitel 4: Zugriff auf das Dateisystem: Scripting.FileSystemObject
4.10.9 Skip Sub Skip(ByVal Characters As Long)
Überspringt eine beliebige Anzahl von Zeichen.
4.10.10 SkipLine Sub SkipLine
Überspringt eine Zeile.
4.10.11 Write Sub Write(ByVal Text As String)
Schreibt Zeichen in eine geöffnete Textdatei. Die Textdatei muß entweder neu angelegt oder im Append-Modus geöffnet werden. ’ 4-72.vbs set FileSystemObject = CreateObject("Scripting.FileSystemObject") set textstream = FileSystemObject.OpenTextFile("C:\TEST.TXT", _ 8, true) Call TextStream.Write("Hallo!") TextStream.Close
Dieses Script hängt eine neue Textzeile an die Datei TEST.TXT an. Sie können den Erfolg sofort mit Script 4-71.VBS prüfen – oder die Datei einfach öffnen. Die Codezahl 8 öffnet die Datei im Append-Modus. Die übrigen Codezahlen sind oben bei OpenTextFile aufgelistet.
4.10.12 WriteBlankLines Sub WriteBlankLines(ByVal Lines As Long)
Schreibt beliebig viele leere Zeilen in eine Textdatei.
4.10.13 WriteLine Sub WriteLine([ByVal Text As String])
Schreibt Text und einen »Wagenrücklauf« in die Textdatei.
119
5
Zugriff auf die Webansicht: Shell.Application
Das Shell.Application-Objekt ist ein Allzweckobjekt, so ähnlich wie ein Schweizer Offiziersmesser. Es ist die Geheimtür, über die Ihre Scripts tief in die Interna der neuen Windows-Desktops dringen können, und nebenbei liefert das Objekt so nützliche Dinge wie Funktionen, um alle Fenster vorübergehend unsichtbar zu machen. Leider ist das Objekt aber nicht auf allen Windows-Versionen verfügbar. Von Hause aus dabei ist es nur bei Windows 98 und Windows 2000. Windows 95 und -NT-Benutzer können es zwar nachrüsten, aber sonderbarerweise kommt es ausschließlich als Teil des Internet Explorer 4. Wer den Internet Explorer 5 installiert, muß auf das Objekt verzichten.
5.1
Das Objekt-Modell kennenlernen
Das Shell.Application Objekt kann einfach oder komplex sein, je nachdem, wie tief Sie einsteigen wollen. Für den Anfang bietet es ein gutes Dutzend höchst interessanter Methoden, die ohne weiteres Nachdenken einsetzbar sind.
Bild 5.1: Das Objekt-Modell des Shell-Application-Objekts
120
Kapitel 5: Zugriff auf die Webansicht: Shell.Application
Wer mehr erreichen möchte, kann außerdem mit dem Objekt Shell.Application tief in die Windows-Webansicht einsteigen. Alle Ordner, Dateien und sogar die einzelnen Kontextmenübefehle dieser Dateien sind über das Shell.Application-Objekt erreichbar.
5.2
Die Service-Funktionen des Shell.Application-Objekts
Die folgende Tabelle listet alle Funktionen auf, die Sie mit dem Shell.Application-Objekt sofort einsetzen können, ohne sich größere Gedanken über das Objektmodell machen zu müssen. Alle nicht besonders gekennzeichneten Funktionen stehen ab SHELL32.DLL Version 4.71 zur Verfügung. Die mit (5.0) gekennzeichneten Funktionen sind erst ab SHELL32.DLL Version 5.00 verfügbar (Windows 2000). Befehl
Beschreibung
CanStartStopService CascadeWindows ControlPanelItem EjectPC Explore FileRun FindComputer FindFiles FindPrinter GetSystemInformation Help IsRestricted IsServiceRunning MinimizeAll Open RefreshMenu ServiceStart ServiceStop SetTime ShellExecute ShowBrowserBar ShutdownWindows Suspend TileHorizontally TileVertically TrayProperties UndoMinimizeALL
(5.0) Wahr, wenn der angemeldete Benutzer den genannten Dienst beenden kann Stellt alle sichtbaren Fenster überlappend dar Ruft ein Modul der Systemsteuerung auf Löst den Undock-Mechanismus bei eingedockten Notebooks aus Öffnet ein Explorerfenster Öffnet das Ausführen-Dialogfenster Sucht nach Computern Sucht nach Dateien (5.0) Sucht nach Druckern (5.0) Universalbefehl, um Systeminformationen auszulesen Ruft die Windows-Hilfe auf (5.0) noch keine Funktion (5.0) True, wenn der genannte Dienst läuft Minimiert alle sichtbaren Fenster Öffnet Ordner im einspaltigen Explorer Aktualisiert den Inhalt des Startmenüs (5.0) Startet den benannten Dienst (5.0) Beendet den benannten Dienst Öffnet das Uhrzeit-Dialogfenster (5.0) Öffnet eine Datei und startet die zuständige Applikation (5.0) Zeigt eine der Standard-Browserleisten an Öffnet das Beenden-Dialogfenster Schaltet in den Standby-Modus Ordnet sichtbare Fenster nebeneinander an Ordnet sichtbare Fenster untereinander an Öffnet das Dialogfenster mit den Taskleisten-Eigenschaften Stellt alle mit MinimizeAll minimierten Fenster wieder in Originalgröße dar
Tab. 5.1: Wichtige Service-Funktionen des Shell.Application-Objekts
5.2
5.2.1
Die Service-Funktionen des Shell.Application-Objekts
121
Versionen und aktuelle Shell-Komponenten
Beinahe alle Funktionen der Windows-Shell stammen aus nur drei Dateien: COMCTL32.DLL, SHELL32.DLL und SHLWAPI.DLL. Da besonders die Windows-Shell (der Desktop und die Bedienelemente) in den letzten Jahren intensiv renoviert wurden, kursieren von diesen drei Dateien die unterschiedlichsten Versionen durch die Welt. Das ist ein kleines Problem, denn viele neue Funktionen werden erst mit aktuellsten Versionen dieser Dateien unterstützt. Aus diesem Grund habe ich für Sie den Versions-Dschungel durchleuchtet. Hier das Ergebnis: Datei/Versionsnummer
Bedeutung
SHELL32.DLL/4.00 SHELL32.DLL/4.70 SHELL32.DLL/4.71 SHELL32.DLL/4.72 SHLWAPI.DLL/5.00 SHELL32.DLL/5.00 COMCTL32.DLL/5.80 COMCTL32.DLL/5.81
Windows 95/Windows NT 4.0 Internet Explorer 3.x Internet Explorer 4.0 Internet Explorer 4.1/Windows 98 Internet Explorer 5.0 Windows 2000 Internet Explorer 5.0 Windows 2000
Tab. 5.2: Versionen der Shell.Application-Bestandteile
Das folgende Script verrät Ihnen ohne weiteres Kopfzerbrechen, welche Versionen auf Ihrem Computer installiert sind und welches Betriebssystem bzw. welche Internet Explorer-Version sich daraus ergibt:
Bild 5.2: Ihr Script ermittelt den Versionsstand Ihres Betriebssystems ’ 5-1.VBS set fs = CreateObject("Scripting.FileSystemObject") ' Systemordner öffnen set system = fs.GetSpecialFolder(1) pfad = system.path ' Diese Dateien datei1 = pfad & datei2 = pfad & datei3 = pfad &
sind wichtig "\shell32.dll" "\shlwapi.dll" "\comctl32.dll"
' Versionen dieser Dateien bestimmen ver1 = fs.GetFileVersion(datei1) ver2 = fs.GetFileVersion(datei2)
122
Kapitel 5: Zugriff auf die Webansicht: Shell.Application
ver3 = fs.GetFileVersion(datei3) ver1 = left(ver1, Instr(3, ver1, ".")-1) ver2 = left(ver2, Instr(3, ver2, ".")-1) ver3 = left(ver3, Instr(3, ver3, ".")-1) ’ Betriebssystem-Konfiguration ermitteln os = "unbekannt" ie = "unbekannt" select case ver1 case "4.0" : os = case "4.7" : ie = case "4.71" : ie = case "4.72" : ie = "4.1" os = "Windows case "5.0" : os = end select
"Windows 95/NT4" "3.x" "4.0"
98/Desktop Upgraded Windows 95/NT4" "Windows 2000"
select case ver2 case "5.0" : end select
ie = "5.0"
select case ver3 case "5.8" : case "5.81" : end select
ie = "5.0" os = "Windows 2000"
msg = "Betriebssystem: " & os & vbCr & "IE: " & ie MsgBox msg, vbInformation
5.3
Beispielscripts für Shell.Application
Damit Sie die für Sie interessanten Funktionen sofort einsetzen können, habe ich für Sie einen Shell.Application-Werkzeugkasten gezimmert. Die Beispiele sind sofort lauffähig und können direkt in eigene Projekte übernommen werden.
5.3.1
CanStartStopService
Function CanStartStopService(ByVal ServiceName As String)
Diese Funktion ist nur bei Windows 2000 verfügbar und ermittelt, ob Sie die Berechtigung haben, einen bestimmten Dienst (wie in diesem Beispiel den DHCP-Dienst) zu steuern: ’ 5-2.vbs set IShellDispatch2 = CreateObject("Shell.Application") MsgBox "Kann P&P-Dienst gesteuert werden? " & _
5.3
Beispielscripts für Shell.Application
123
IShellDispatch2.CanStartStopService("PlugPlay") MsgBox "Kann DHCP-Dienst gesteuert werden? " & _ IShellDispatch2.CanStartStopService("DHCP")
5.3.2
CascadeWindows
Sub CascadeWindows ’ 5-3.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.CascadeWindows
5.3.3
ControlPanelItem
Sub ControlPanelItem(ByVal szDir As String)
Öffnet ein Systemsteuerungsmodul. Welche Module es bei Ihnen gibt, finden Sie leicht heraus. Starten Sie einfach im Startmenü mit Suchen und Dateien/Ordner eine festplattenweite Fahndungsaktion nach *.CPL. ’ 5-4.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.ControlPanelItem("main.cpl")
5.3.4
EjectPC
Sub EjectPC
Nur für Notebooks in Dockingstationen interessant: »undockt« den Computer so, als hätten Sie ihn aus der Dockingstation genommen. ’ 5-5.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.EjectPC
5.3.5
Explore
Sub Explore(ByVal vDir)
Öffnet einen beliebigen Ordner. Auch virtuelle Ordner sind erlaubt, zum Beispiel Codezahl 0 für den Desktop. Die vollständige Liste der Codezahlen finden Sie in Kapitel 6.2.3. ’ 5-6.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.Explore("C:\") Call IShellDispatch2.Explore(0)
124 5.3.6
Kapitel 5: Zugriff auf die Webansicht: Shell.Application
FileRun
Sub FileRun
Öffnet das Ausführen-Dialogfenster. ’ 5-7.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.FileRun
5.3.7
FindComputer
Sub FindComputer
Öffnet den Suchen-Dialog für Computer, sofern er installiert ist. ’ 5-8.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.FindComputer
5.3.8
FindFiles
Sub FindFiles
Öffnet das Suchen-Dialogfenster für Dateien/Ordner. ’ 5-9.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.FindFiles
5.3.9
FindPrinter
Sub FindPrinter(ByVal Name As String, ByVal location As String, ByVal model As String)
Öffnet das Suchen-Fenster für den Drucker-Dialog. Wird nur bei Windows 2000 unterstützt. Mit Name, location und model können Sie Vorgaben ins Dialogfenster schreiben. Alle drei Argumente sind optional und können also auch weggelassen werden. ’ 5-10.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.FindPrinter(Name, location, model)
5.3.10 GetSystemInformation Function GetSystemInformation(ByVal Name As String)
Liefert Informationen über das Betriebssystem. Verfügbar nur bei Windows 2000.
5.3
Beispielscripts für Shell.Application
125
’ 5-11.vbs set shell = CreateObject("Shell.Application") ram = shell.GetSystemInformation("PhysicalMemoryInstalled") msg = FormatNumber(ram/1024^2, 1) & " MB" MsgBox msg, vbInformation
Information
Beschreibung
DirectoryServiceAvailable DoubleClickTime ProcessorLevel
True, wenn Service verfügbar ist Doppelklickzeit in Millisekunden Art des Prozessors 3: x386 4: x486 5: Pentium 6: Pentium II 7: Pentium III Prozessorgeschwindigkeit in MHz Art des Prozessors Vorhandener RAM-Speicher in Byte
ProcessorSpeed ProcessorArchitecture PhysicalMemoryInstalled
Tab. 5.3: Informationen über das Betriebssystem erfragen
5.3.11 Help Sub Help
Ruft die Windows-Hilfe auf. Falls bereits eine Instanz der Hilfe läuft, passiert gar nichts. ’ 5-13.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.Help
5.3.12 IsRestricted Function IsRestricted(ByVal Group As String, ByVal Restriction As String) As Long
Funktion, die zukünftig in dieser Form unterstützt werden soll und Rechte eines Benutzers liefert. Zur Zeit wird diese Funktion aber noch von keiner Windows-Version unterstützt. ’ 5-13.vbs set IShellDispatch2 = CreateObject("Shell.Application") MsgBox IShellDispatch2.IsRestricted(ByVal Group As String, ByVal Restriction As String)
126
Kapitel 5: Zugriff auf die Webansicht: Shell.Application
5.3.13 IsServiceRunning Function IsServiceRunning(ByVal ServiceName As String)
Prüft, ob ein bestimmter Dienst zur Zeit läuft. Verfügbar nur bei Windows 2000. ’ 5-14.vbs set shell = CreateObject("Shell.Application") MsgBox "Läuft DHCP? " & shell.IsServiceRunning("DHCP")
5.3.14 MinimizeAll Sub MinimizeAll
Minimiert alle Fenster und macht den Blick auf den Desktop frei. Nur liegengebliebene Dialogfenster bleiben sichtbar. ' 5-15.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.MinimizeAll
5.3.15 Open Sub Open(ByVal vDir)
Öffnet einen beliebigen Ordner oder virtuellen Ordner im einspaltigen einfachen Explorer. Siehe auch Explorer. ’ 5-16.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.Open("C:\") Call IShellDispatch2.Open(3) ’Systemsteuerung
5.3.16 RefreshMenu Sub RefreshMenu
Aktualisiert das Startmenü. ’ 5-17.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.RefreshMenu
5.3.17 ServiceStart Function ServiceStart(ByVal ServiceName As String, ByVal Persistent)
5.3
Beispielscripts für Shell.Application
127
Startet einen Dienst vorübergehend oder als ständige Einstellung. Verfügbar nur bei Windows 2000. set IShellDispatch2 = CreateObject("Shell.Application") MsgBox IShellDispatch2.ServiceStart(ByVal ServiceName As String, ByVal Persistent)
5.3.18 ServiceStop Function ServiceStop(ByVal ServiceName As String, ByVal Persistent)
Beendet einen Dienst vorübergehend oder als ständige Einstellung. Verfügbar nur bei Windows 2000. set IShellDispatch2 = CreateObject("Shell.Application") MsgBox IShellDispatch2.ServiceStop(ByVal ServiceName As String, ByVal Persistent)
5.3.19 SetTime Sub SetTime
Ruft das Dialogfenster auf, mit dem die Uhrzeit und das Datum eingestellt werden. ’ 5-18.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.SetTime
5.3.20 ShellExecute Sub ShellExecute(ByVal File As String, [ByVal vArgs], [ByVal vDir], [ByVal vOperation], [ByVal vShow])
Ruft Befehle einer Datei auf, die diese Datei in ihrem Kontextmenü anbietet. Damit können Dateien mit dem Standardprogramm geöffnet werden. Verfügbar nur bei Windows 2000. Das nächste Script öffnet die Datei C:\TEST.TXT mit dem Programm, das für TXT-Dateien zuständig ist. Die Datei öffnet sich in einem maximierten Fenster: ’ 5-19.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.ShellExecute("C:\TEST.TXT",,,,3)
Argument
Beschreibung
File vArgs
Name der Datei Argumente, die an die Datei geliefert werden sollen. Sinnvoll nur, wenn Sie als File ein Programm angeben
128
Kapitel 5: Zugriff auf die Webansicht: Shell.Application
Argument
Beschreibung
vDir
Verzeichnis, in dem File liegt (falls Sie bei File keinen vollständigen Pfadnamen angegeben haben) vOperation Befehl aus dem Kontextmenü, den das Script ausführen soll. Wird kein Befehl angegeben, dann wird der Standardbefehl gewählt. Das ist in der Regel der Befehl Öffnen. Sie könnten ebenso gut auch Standardbefehlsnamen angeben, zum Beispiel print, um die Datei auszudrucken. vShow Art des Fensters: 0: unsichtbar ausführen 1: normale Größe 2: Minimiert 3: Maximiert 4: Letzte Fenstereinstellung 5: Wiederherstellen 7: Minimiert. Aktives Fenster bleibt aktiv 10: Vorgabe der Datei/des Programms übernehmen Tab. 5.4: Argumente, mit denen Sie den Befehl füttern können
5.3.21 ShowBrowserBar Function ShowBrowserBar(ByVal bstrClsid As String, ByVal bShow)
Kann von Scripts aus nicht angesprochen werden.
5.3.22 ShutdownWindows Sub ShutdownWindows
Aktiviert den Windows-Beenden-Dialog. ’ 5-20.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.ShutdownWindows
5.3.23 Suspend Sub Suspend
Aktiviert den Standby-Modus, sofern aktiviert, und ohne weitere Rückfragen. ’ 5-21.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.Suspend
5.3
Beispielscripts für Shell.Application
5.3.24 TileHorizontally Sub TileHorizontally
Ordnet die Fenster nebeneinander an. ’ 5-22.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.TileHorizontally
5.3.25 TileVertically Sub TileVertically
Ordnet die Fenster untereinander an. ’ 5-23.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.TileVertically
5.3.26 TrayProperties Sub TrayProperties
Öffnet die Eigenschaften-Dialogseite der Taskleiste. set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.TrayProperties
5.3.27 UndoMinimizeALL Sub UndoMinimizeALL
Macht alle mit MinimzeAll unsichtbar gemachten Fenster wieder sichtbar. ’ 5-25.vbs set IShellDispatch2 = CreateObject("Shell.Application") Call IShellDispatch2.MinimizeALL MsgBox "Wir machen den Weg frei..." Call IShellDispatch2.UndoMinimizeALL
129
131
6
Zugriff auf die Webansicht: Shell.Application
Das Shell.Application-Objekt kann weitaus mehr, als nur die Service-Funktionen aus dem vorangegangenen Kapitel bereitzustellen. Es ist Ihre Geheimtür in die versteckte Welt der Ordner und Dateien aus Sicht des Explorers. Ihre Scripts haben also zwei ganz unterschiedliche Optionen, um mit Dateien und Ordnern zu hantieren:
Entweder greifen Sie auf die Funktionen des Scripting.FileSystemObject zu. Dieses Objekt haben Sie bereits in Kapitel 4 kennengelernt. Seine Funktionen sind speziell für Scripts geschaffen worden, und dieses Objekt ist standardmäßig immer vorhanden, wenn Sie den WSH installiert haben.
Oder aber Sie machen es wie Windows selbst und verwenden das Shell.Application-Objekt. Durch dieses Objekt stehen Ihnen alle Funktionen zur Verfügung, die auch der normale Explorer nutzt. Die Möglichkeiten dieses Objekts gehen in vielen Bereichen weit über die des Scripting.FileSystemObject hinaus. Allerdings ist das Shell.Application-Objekt nur bei Windows 98 und bei Windows 2000 vorhanden. Tip: Shell.Application-Objekt nachrüsten Das Shell.Application-Objekt kann auch nachgerüstet werden: Bei Windows 95 und NT 4.0 genügt es, den Internet Explorer 4 zu installieren. Der Internet Explorer 5 dagegen bringt das Shell.Application-Objekt nicht mit.
6.1
Auf Ordner zugreifen: das Folder-Objekt
Kernstück des Shell.Application-Objekts ist das Folder-Objekt. Es repräsentiert einen beliebigen Ordner. Bei diesem Ordner muß es sich – im Gegensatz zum Scripting.FileSystemObject – nicht um einen regulären Dateiordner handeln. Auch virtuelle Ordner wie die Systemsteuerung oder das Schriftarten-Fenster werden unterstützt. Wie Sie virtuelle Ordner ansprechen, ist Thema in Kapitel 6.2.3.
132
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Bild 6.1: Mit Shell.Application auf Ordner und Objekte zugreifen
Die wichtigste Frage ist also: Wie erhält man überhaupt ein Folder-Objekt? Viele Wege führen ans Ziel:
Verwenden Sie die Funktionen BrowseForFolder oder NameSpace, um einen beliebigen Ordner anzusprechen und ein Folder-Objekt zu bekommen. Beispielscripte finden Sie in Kapitel 6.1.1.
Klinken Sie sich in einen bereits geöffneten Explorer ein, und »stehlen« Sie dessen FolderObjekt. Sie können so in laufende Explorer eingreifen.
Öffnen Sie scriptgesteuert selbst einen Explorer, stellen Sie darin den gewünschten Ordner ein, und greifen Sie auf das Folder-Objekt des Explorers zu. Beispiele erwarten Sie in Kapitel 6.2.4.
6.1.1
Auf ein unsichtbares Folder-Objekt zugreifen
NameSpace liefert auf Wunsch das Folder-Objekt eines beliebigen Ordners zurück. So einfach listen Sie damit den Inhalt eines Ordners auf: ’ 6-1.vbs set shell = CreateObject("Shell.Application") ’ auf Ordner C: zugreifen set folder = shell.NameSpace("C:\") ’ Inhalt des Ordners erfragen set folderitems = folder.items ’ Alle Inhalte auflisten
6.1
Auf Ordner zugreifen: das Folder-Objekt
133
for each folderitem in folderitems liste = liste & folderitem.path & vbCr next MsgBox liste
Sie können den Ordner auch bequem per Dialogfenster aussuchen. Dafür ist BrowseForFolder zuständig:
Bild 6.2: Bequem per Dialogfenster Ordner aussuchen ’ 6-2.vbs set shell = CreateObject("Shell.Application") ’ auf Ordner zugreifen set folder = shell.BrowseForFolder(0,"Ordner aussuchen!",0,"C:\") ’ Inhalt des Ordners erfragen set folderitems = folder.items ’ Alle Inhalte auflisten for each folderitem in folderitems liste = liste & folderitem.path & vbCr next MsgBox liste
Zusätzlich zu den beiden Funktionen BrowseForFolder und NameSpace können Sie außerdem auch auf das Folder-Objekt zugreifen, das in einem sichtbaren Explorerfenster angezeigt wird. Diese Variante stelle ich Ihnen etwas weiter unten in Kapitel 6.2.4 vor. Konzentrieren Sie sich zunächst auf das Folder-Objekt selbst: Was kann man damit bewerkstelligen?
134 6.2
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Der Inhalt eines Ordners: das FolderItem-Objekt
Allein für sich nützt Ihnen das Folder-Objekt nur wenig. Es ist nur ein Container, und wirklich interessant sind die Objekte darin. Alles, was der Ordner enthält, wird durch FolderItem-Objekte repräsentiert. Dieses Objekt enthält die wirklich wichtigen Informationen. Wie Sie alle FolderItem-Objekte eines Ordners auflisten, haben Sie gerade gesehen: Die Items-Eigenschaft des Folder-Objekts liefert eine FolderItems-Sammlung zurück. Die können Sie anschließend mit for each...next durchlaufen und nacheinander alle FolderItem-Objekte herauspicken.
6.2.1
Direkt ein FolderItem-Objekt ansprechen
Viel häufiger jedoch wollen Sie wahrscheinlich direkt ein FolderItem-Objekt ansprechen: eine bestimmte Datei zum Beispiel, oder einen Ordner. Genau das ist möglich: Verbinden Sie sich zuerst über NameSpace mit dem Ordner, in dem das Objekt liegt, und greifen Sie dann über ParseName auf das FolderItem-Objekt zu. Das nächste Script liefert eine universelle Funktion, die das erledigt. Stellen Sie nur sicher, daß es die Dateien und Ordner auch wirklich gibt, auf die das Script zugreifen will: ’ 6-3.vbs MsgBox GetItem("C:\").Name MsgBox GetItem("C:\WINDOWS").Name MsgBox GetItem("C:\MSDOS.SYS").Name function GetItem(pfad) ’ pfadname und dateiname trennen, falls möglich if not right(pfad,1)="\" then dateiname = mid(pfad, InstrRev(pfad, "\")+1) if Instr(dateiname, ".")=0 then pfadname = pfad dateiname = "" else pfadname = left(pfad, InstrRev(pfad, "\")) end if else pfadname = pfad end if set shell = CreateObject("Shell.Application") set folder = shell.NameSpace(pfadname) if dateiname = "" then set GetItem = Self(folder) else
6.2
Der Inhalt eines Ordners: das FolderItem-Objekt
135
set GetItem = folder.ParseName(dateiname) end if end function function Self(obj) title = obj.title set folderitems = obj.parentfolder.items for each folderitem in folderitems if folderitem.isFolder then if folderitem.GetFolder.Title=title then exit for end if end if next set self = folderitem end function
Wenn Sie keine Lust auf Details haben, dann setzen Sie die Funktion GetItem einfach in Ihren Projekten ein. Das Ergebnis ist entweder das FolderItem-Objekt des gewünschten Ordners oder der gewünschten Datei. Oder es wird ein leeres Objekt zurückgeliefert. Dann wissen Sie: Das gewünschte Objekt existiert nicht. Mit TypeName können Sie das zurückgelieferte Objekt prüfen und auf leere Objekte reagieren: If TypeName(objekt) = "Nothing" then MsgBox "Leeres Objekt!" Else MsgBox "Objekt existiert!" End if
Vielleicht interessieren Sie sich aber auch dafür, wie GetItem eigentlich seine Aufgabe meistert. Hier die Details: GetItem akzeptiert Ordner- und Dateinamen und splittet dann den Ordner- und den Dateianteil. Anschließend verbindet es sich via NameSpace mit dem Ordner. Wurde ein Dateipfad übergeben, dann ruft das Script anschließend ParseName auf, um das FolderItem-Objekt der Datei zu bekommen. Sie bekommen das FolderItem-Objekt also schnell und direkt über das Zusammenspiel zwischen NameSpace und ParseName. Etwas schwieriger ist das, wenn Sie einen Ordner angegeben haben. Das Folder-Objekt des Ordners bietet nämlich keinen Weg an, um an dessen FolderItem-Objekt im übergeordneten Ordner heranzukommen. Deshalb setzt das Script die zusätzliche Funktion Self ein. Die ermittelt das FolderItem-Objekt eines Folders.
136
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Bild 6.3: Zusammenhänge zwischen Ordnern und deren Inhalt
Als »Erkennungszeichen« liest diese Funktion zunächst den Titel des Folder-Objekts und merkt ihn sich. Danach verschafft es sich via ParentFolder Zugriff auf den übergeordneten Ordner. Anschließend durchläuft eine for each...next-Schleife alle FolderItem-Objekte des übergeordneten Ordners. Eins davon muß dem gesuchten Ordner entsprechen. Mit isFolder prüft das Script bei jedem FolderItem-Objekt, ob es sich um einen Ordner handelt. Falls ja, dann erfragt es über GetFolder.Title dessen Titel und vergleicht ihn mit dem Titel des gesuchten Ordners. Stimmen beide überein, dann ist der gesuchte Ordner im übergeordneten Ordner gefunden, und die Schleife wird abgebrochen. Das FolderItem-Objekt ist gefunden. Bei Windows 2000 ist dieser relativ aufwendige Umweg nicht nötig. Hier bietet das Folder-Objekt über seine Eigenschaft Self von sich aus das gesuchte FolderItem-Objekt an, so daß sich das Script stark vereinfacht: ’ 6-4.vbs MsgBox GetItem("C:\").Name MsgBox GetItem("C:\WINDOWS").Name MsgBox GetItem("C:\MSDOS.SYS").Name function GetItem(pfad) ' pfadname und dateiname trennen, falls möglich if not right(pfad,1)="\" then dateiname = mid(pfad, InstrRev(pfad, "\")+1) if Instr(dateiname, ".")=0 then pfadname = pfad dateiname = "" else pfadname = left(pfad, InstrRev(pfad, "\")) end if else pfadname = pfad end if
6.2
Der Inhalt eines Ordners: das FolderItem-Objekt
137
set shell = CreateObject("Shell.Application") set folder = shell.NameSpace(pfadname) if dateiname = "" then set GetItem = folder.self else set GetItem = folder.ParseName(dateiname) end if end function
6.2.2
Mit BrowseForFolder Ordnernamen erfragen
Dank der neuen Self-Eigenschaft bei Windows 2000 läßt sich hier die BrowseForFolder-Funktion endlich bequem dazu einsetzen, um Ordnernamen zu erfragen. Bei Windows 9x und NT geht dies nur über den Umweg des übergeordneten Ordners, so wie oben beschrieben.
Bild 6.4: Bei Windows 2000 können Scripts kinderleicht nach Ordnernamen fragen
So erfragen Sie bei Windows 2000 einen Ordnernamen: ’ 6-5.vbs set shell = CreateObject("Shell.Application") set folder = shell.BrowseForFolder(0, _ "Bitte suchen Sie sich einen Ordner aus!", 0, "C:\") MsgBox folder.self.path
138 6.2.3
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Virtuelle Ordner über Codezahlen ansprechen
Sowohl BrowseForFolder als auch NameSpace kommen nicht nur mit normalen Ordnern zurecht. Beide Funktionen akzeptieren anstelle eines Pfadnamens wahlweise auch eine Codezahl, um einen der vielen virtuellen Windows-Ordner anzusprechen. Codezahl und Beschreibung
Virtueller Ordner
0: Desktop 1: Internet Explorer 2: Programme
Pfadname zum Ordner, der den Desktop repräsentiert ::{871C5380-42A0-1069-A2EA-08002B30309D} Pfadname zum Ordner, in dem die persönlichen Programm-Links des Programme-Menüs liegen ::{21EC2020-3AEA-1069-A2DD-08002B30309D} ::{2227A280-3AEA-1069-A2DE-08002B30309D} Pfadname zum Ordner, in dem die persönlichen eigenen Dateien abgelegt werden Ordner, in dem die persönlichen Internet-Favoriten abgelegt werden Ordner, in dem die persönlichen Autostart-Programme hinterlegt sind Ordner, in dem die kürzlich verwendeten Dokumente hinterlegt sind Ordner, in dem die Senden an-Menü Ziele gespeichert sind ::{645FF040-5081-101B-9F08-00AA002F954E} Ordner, in dem das persönliche Startmenü gespeichert ist Ordner, in dem die persönlichen Desktop-Dateien lagern ::{20D04FE0-3AEA-1069-A2D8-08002B30309D} ::{208D2C60-3AEA-1069-A2D7-08002B30309D} Ordner, in dem nachträglich zur Netzwerkumgebung hinzugefügte Links lagern Systemweiter Ordner mit den installierten Schriftarten Ordner mit den persönlichen Dokumentenvorlagen Ordner mit den Startmenüeinträgen, die für alle Benutzer gelten Ordner mit den Programmlinks, die für alle Benutzer gelten Ordner mit den Autostart-Programmen, die für alle Benutzer gelten Ordner mit den Desktop-Elementen, die für alle Benutzer gelten Ordner mit den persönlichen Anwendungsdaten Ordner mit den persönlichen Zusätzen zum Drucker-Ordner Ordner, in denen persönliche Applikationsdaten gespeichert werden Ordner mit den Favoriten für alle Benutzer Ordner für den persönlichen Internet-Cache Ordner mit den persönlichen Internet-Cookies Ordner mit den persönlichen Internetseiten, die kürzlich besucht wurden Ordner mit Anwendungsdaten für alle Benutzer Windows-Ordner Systemordner Ordner mit den Programm-Installationen Ordner, in dem die persönlichen Bilder abgespeichert werden
3: Systemsteuerung 4: Drucker 5: Eigene Dateien 6: Favoriten 7: Autostart 8: Recent 9: SendTo 10: Papierkorb 11: Startmenü 16: Desktop 17: Arbeitsplatz 18: Netzwerkumgebung 19: Netzwerkumgebung 20: Fonts 21: Vorlagen 22: Startmenü 23: Programme 24: Autostart 25: Desktop 26: Anwendungsdaten 27: Druckumgebung 28: Anwendungsdaten 31: Favoriten 32: Temporary Internet Files 33: Cookies 34: Verlauf 35: Anwendungsdaten 36: Windows 37: system32 38: Programme 39: Eigene Bilder
6.2
Der Inhalt eines Ordners: das FolderItem-Objekt
139
Codezahl und Beschreibung
Virtueller Ordner
40: Benutzerprofil
Ordner, in dem die persönlichen Einstellungen des aktuellen Benutzers gespeichert werden Systemordner Ordner mit den gemeisam genutzten Komponenten installierter Programme Ordner mit den Dokumentenvorlagen für alle Benutzer Dokumentenordner für alle Benutzer Programmgruppe »Verwaltung« für alle Benutzer Programmgruppe »Verwaltung« für aktuellen Benutzer ::{7007ACC7-3202-11D1-AAD2-00805FC1270E}
41: system32 43: Gemeinsame Dateien 45: Vorlagen 46: Dokumente 47: Verwaltung 48: Verwaltung 49: Netzwerk- und DFÜVerbindungen
Tab. 6.1: Virtuelle Ordner über Codezahlen und GUIDs ansprechen
Tip: Informationen – bei Windows 2000 am meisten! Nicht alle Codezahlen werden bei Windows 9x oder NT funktionieren. Erst Windows 2000 bringt das volle Set an Informationen mit.
Die meisten Einträge entsprechen tatsächlichen Dateisystem-Ordnern, die lediglich eine besondere Aufgabe erfüllen. Wollen Sie zum Beispiel bei Windows 2000 den tatsächlichen Ordnernamen Ihres Startmenüs erfragen, dann geht das beispielsweise so: ’ 6-6.vbs set shell = CreateObject("Shell.Application") set folder = shell.NameSpace(11) MsgBox folder.title & ": " & folder.self.path
Bild 6.5: Systemordner und deren augenblicklichen Aufenthaltsort bestimmen
Bei Windows 9x und NT ist dazu wieder der Umweg erforderlich – so wie oben beschrieben –, denn hier gibt es die Self-Eigenschaft noch nicht. Um die Pfadnamen spezieller Ordner zu ermitteln, ist es deshalb oft einfacher, die SpecialFolders-Funktion des Wscript.Shell-Objekts zu nutzen. Die funktioniert nämlich auch bei Windows 9x und NT schnell und direkt. Informationen darüber finden Sie in der Hilfedatei auf der Buch-CD: \wsh\dokumentation\scripthostdocu.exe. Einige Ordner der Tabelle sind »echte« virtuelle Ordner, die Sie nirgendwo auf der Festplatte finden. Die Systemsteuerung gehört zum Beispiel dazu. Solche virtuellen Ordner können deshalb nicht mit einem normalen Pfadnamen bezeichnet werden. Statt dessen verwendet Windows für diese Ordner eine GUID, eine global eindeutige IDNummer. Sie steht immer in geschweiften Klammern.
140
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Die Code-Kennzahl aus der Tabelle oben ist wichtig, wenn Sie einen virtuellen Ordner via NameSpace oder BrowseForFolder ansprechen wollen. Die GUID in den geschweiften Klammern dagegen ist wichtig, wenn Sie den virtuellen Ordner über den normalen Explorer öffnen möchten.
Bild 6.6: Inhalt der Systemsteuerung auflisten
Das folgende Script greift zum Beispiel auf die Systemsteuerung zu und listet den Inhalt auf: ’ 6-7.vbs set shell = CreateObject("Shell.Application") set folder = shell.NameSpace(3) for each object in folder.Items list = list & object.Name & vbCr next MsgBox list
Auf ähnliche Weise könnten Sie auch das BrowseForFolder-Dialogfenster auf einen virtuellen Ordner voreinstellen. Das nächste Script verwendet als Wurzelverzeichnis den Arbeitsplatz: set shell = CreateObject("Shell.Application") set folder = shell.BrowseForFolder(0,"Arbeitsplatz",0,17) MsgBox TypeName(folder)
6.2
Der Inhalt eines Ordners: das FolderItem-Objekt
141
Bild 6.7: Wurzelverzeichnis des Dialogfensters auf den Arbeitsplatz beschränken
6.2.4
Mit GUIDs virtuelle Ordner im Explorer sichtbar machen
Wofür sind die GUIDs in den geschweiften Klammern gut? GUIDs sind – auch wenn diese Tatsache kaum bekannt ist – mit dem Explorer zu erreichen, genauso wie echte Ordner. Die GUIDs lassen sich sogar zu echten verschachtelten Pfadnamen zusammensetzen. Genau das kann ausgesprochen praktisch sein, denn Sie werden gleich sehen, daß es neben den beiden Befehlen BrowseForFolder und NameSpace noch eine dritte Möglichkeit gibt, sich ein Folder-Objekt zu verschaffen. Bevor Sie diese dritte Möglichkeit ausprobieren können, brauchen Sie jedoch eine Möglichkeit, virtuelle Ordner über den Explorer zu öffnen. Der »NameSpace« des Explorers ist der Desktop. Alles, was auf dem Desktop zu sehen ist, kann über den Explorer erreicht werden. Aus der Tabelle oben wissen Sie, daß die Netzwerkumgebung die GUID {208D2C60-3AEA-1069-A2D7-08002B30309D} besitzt. Weil das Symbol der Netzwerkumgebung direkt auf dem Desktop liegt, können Sie die Netzwerkumgebung sofort im Explorer anzeigen lassen: 1. Wählen Sie im Startmenü Ausführen. Die Befehlszeile öffnet sich. 2. Geben Sie nun ein: ::{208D2C60-3AEA-1069-A2D7-08002B30309D} [Enter]. Ein Explorerfenster öffnet sich und zeigt tatsächlich die Netzwerkumgebung an. Tip: NameSpaces – so funktioniert die Sache Normale Dateisystempfade sind nur eine Methode, um mit dem Explorer Informationen anzuzeigen. Stellen Sie zwei umgekehrte Schrägstriche voran, dann kann der Explorer auch UNC-Netzwerkpfade anzeigen, zum Beispiel so: \\COMPI1\ORDNER12. Wollen Sie dagegen mit dem Explorer eine Webseite betrachten, dann ist das Präfix http:// wichtig. Dies alles ist weitgehend bekannt. Unbekannter ist, daß Sie mit dem Präfix :: direkt virtuelle Ordner ansprechen. Generell gilt: Der Explorer kann universell jede nur erdenkliche Art von Information anzeigen und braucht lediglich Zugang zum entsprechenden Informationssystem, dem »NameSpace«.
142
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Wenn Sie dasselbe allerdings mit der Systemsteuerung versuchen, dann scheitert die Sache. Mit ::{21EC2020-3AEA-1069-A2DD-08002B30309D} weiß Windows ganz offenbar nichts anzufangen. Und wieso? Weil die Systemsteuerung nicht direkt auf dem Desktop liegt! Hier ist also dasselbe Malheur passiert als wenn Sie im vertrauten Dateisystem versucht hätten, einfach einen Ordnernamen anzugeben. Das dürfen Sie nicht, auch im Dateisystem gibt es eine Wurzel: das Laufwerk. Wo Sie also im Dateisystem c:\ordner\unterordner angeben, um zu unterordner zu gelangen, müssen Sie im »virtuellen« Windows-Dateisystem ebenfalls den kompletten Pfad angeben. Die Systemsteuerung ist zum Beispiel im Arbeitsplatz-Fenster zu sehen. Das Arbeitsplatz-Fenster wiederum ist auf dem Desktop zu sehen, der Wurzel des virtuellen Dateisystems. Weil das Arbeitsplatz-Fenster die GUID ::{20D04FE0-3AEA-1069-A2D8-08002B30309D} trägt, lautet der komplette Pfadname zur Systemsteuerung: ::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\::{21EC2020-3AEA1069-A2DD-08002B30309D}. Geben Sie diese Kolonne in Ihr Ausführen-Fenster ein, dann öffnet der Explorer tatsächlich die Systemsteuerung.
Bild 6.8: Eine Systemsteuerung völlig ohne Ballast und Menüs
Natürlich werden Sie sich in der Praxis hüten, die Systemsteuerung auf solch verschlungenen Wegen zu öffnen, denn schließlich geht es auch einfacher. Interessant werden die sonderbaren GUIDs erst für Ihre Scripts, denn die können nun selbst einen Explorer öffnen, ihn zum virtuellen Ordner navigieren lassen und anschließend das Folder-Objekt herauspicken. Im Gegensatz zu BrowseForFolder und NameSpace bekommen Sie so kein »nacktes« Folder-Objekt, sondern eines, das sichtbar ist. Das hat weitreichende Konsequenzen! Das folgende Script zeigt die grundlegende Technik und öffnet scriptgesteuert in einem Explorerfenster die Systemsteuerung. Weil das Script den Explorer selbst »erzeugt« hat, kann es an seinen internen Schaltelementen herumfummeln und stellt im Beispiel alle Symbolleisten und die Menüleiste ab:
6.2
Der Inhalt eines Ordners: das FolderItem-Objekt
143
’ 6-9.vbs set ie = CreateObject("InternetExplorer.Application") ie.statusbar = false ie.toolbar = false ie.visible = true ie.navigate "::{20D04FE0-3AEA-1069-A2D8-08002B30309D}" _ & "\::{21EC2020-3AEA-1069-A2DD-08002B30309D}"
Das Ergebnis ist eine reine Systemsteuerung, ohne jeglichen Schnickschnack. Doch Ihre Scripts können noch weitaus mehr. Weil der Inhalt des Explorerfensters eigentlich nichts weiter ist als ein Folder-Objekt, kann Ihr Script dieses genauso fernsteuern wie jedes andere Folder-Objekt, das Sie sich vielleicht über BrowseForFolder oder NameSpace verschafft haben. Nur ist das Folder-Objekt dabei sichtbar: set ie = CreateObject("InternetExplorer.Application") ie.statusbar = false ie.toolbar = false ie.visible = true ie.navigate "::{20D04FE0-3AEA-1069-A2D8-08002B30309D}" _ & "\::{21EC2020-3AEA-1069-A2DD-08002B30309D}" MsgBox "Ich markiere jetzt alles, was mit ""S"" beginnt..." for each item in ie.document.folder.items if lcase(left(item.name,1)) = "s" then ie.document.selectItem item, 1+8 end if next WScript.Sleep 3000 MsgBox "Ich füge alles dazu, was mit ""A"" beginnt..." for each item in ie.document.folder.items if lcase(left(item.name,1)) = "a" then ie.document.selectItem item, 1+8 end if next WScript.Sleep 3000 MsgBox "Jetzt markiere ich nur Ordner!" deleteAll = 4 for each item in ie.document.folder.items if item.isFolder then ie.document.selectItem item, 1+8+deleteAll deleteAll = 0 end if next WScript.Sleep 3000 MsgBox "Jetzt schließe ich alles wieder..." ie.quit
144
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Was dieses Script leistet, scheint auf den ersten Blick unglaublich: Es öffnet die Systemsteuerung und demonstriert dann mit spielerischer Leichtigkeit, wie Ihr Script ferngesteuert im Fenster der Systemsteuerung einzelne Einträge markieren kann. Es soll an dieser Stelle nur ein erstes Appetithäppchen sein und zeigen, wieso es sich auf jeden Fall lohnt, das Shell.Application-Objekt mit seinen Folder- und FolderItem-Objekten näher kennenzulernen. Damit gelingen Ihnen nämlich Eingriffe in lebende Explorer, die mit dem Scripting.FileSystemObject absolut unmöglich wären.
6.3
Der innere Aufbau des FolderItem-Objekts
Jetzt, wo Sie wissen, wie Sie auf ein FolderItem-Objekt zugreifen, schauen Sie sich näher an, welche Informationen darin schlummern: Funktion
Beschreibung
Application ExtendedProperty GetFolder GetLink InvokeVerb InvokeVerbEx IsBrowsable IsFileSystem IsFolder IsLink ModifyDate Name Parent Path Size Type Verbs
(5.0) Liefert geheime Zusatzinformation über Objekt Liefert das Folder-Objekt zurück, wenn es sich bei diesem Eintrag um einen Ordner handelt Liefert das Link-Objekt zurück, wenn es sich bei diesem Eintrag um eine Verknüpfung handelt Ruft einen Kontextmenü-Befehl auf (5.0) Öffnet die Datei True, wenn das Objekt selbst Objekte enthält True, wenn das Objekt Teil des Dateisystems ist True, wenn das Objekt ein Ordner ist True, wenn das Objekt ein Link ist Datum und Zeit, an dem das Objekt zuletzt geändert wurde Name des Objekts Übergeordnetes Objekt Pfadname des Objekts Größe des Objekts Typ des Objekts Kontextmenübefehle des Objekts als FolderItemVerbs-Objekt
Tab. 6.2: Das FolderItem-Objekt
6.3.1
ExtendedProperty
Function ExtendedProperty(ByVal bstrPropName As String)
Diese Funktion existiert nur bei Windows 2000. Sie ermöglicht es, an die versteckten Zusatzinformationen einer Datei heranzukommen. Nehmen Sie sich als Beispiel eine Word-Datei. Wenn Sie diese Datei im Explorer mit der rechten Maustaste anklicken und Eigenschaften wählen, dann öff-
6.3
Der innere Aufbau des FolderItem-Objekts
145
net sich ein Dialogfenster. Das Register Datei-Info liefert eine Vielzahl zusätzlicher Informationen über diese Datei. Tip: Zusatzinfos – nicht bei jedem Dateityp vorhanden Ob ein bestimmter Dateityp Zusatzinformationen unterstützt, können Sie sofort ausprobieren. Klicken Sie einfach eine Datei des fraglichen Typs mit der rechten Maustaste an, und wählen Sie Eigenschaften. Wenn das Dialogfenster ein Register namens Datei-Info anbietet, dann können zusätzliche Informationen angeheftet werden. Das Dialogfenster listet die vorhandenen Infos nicht nur auf, sondern kann auch dazu dienen, die Zusatzinformationen zu ändern.
Um an diese Informationen heranzukommen, verwenden Sie (bei Windows 2000) ExtendedProperty. Bei älteren Windows-Versionen können Sie alternativ GetDetailsOf einsetzen (siehe unten). Zunächst brauchen Sie ein Versuchskaninchen. Das nächste Beispiel geht davon aus, daß Sie eine Word-Datei als C:\BEISPIEL.DOC gespeichert haben.
Bild 6.9: Zusatzinformationen in eine Datei eintragen
Damit Ihr Script überhaupt Zusatzinformationen auslesen kann, müssen solche natürlich vorhanden sein. Tragen Sie deshalb als nächstes Zusatzinformationen ein: 1. Suchen Sie sich im Explorer die Datei C:\BEISPIEL.DOC heraus, und klicken Sie sie mit der rechten Maustaste an. Dann wählen Sie Eigenschaften. 2. Klicken Sie auf das Register Datei-Info. Jetzt sehen Sie alle Zusatzinformationen, die dieser Dateityp unterstützt. 3. Klicken Sie auf die Information Autor, und tragen Sie Ihren Namen ein, falls er noch nicht im Feld steht. Dann klicken Sie auf OK.
146
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Tip: Bei mir gibt’s kein Dateiinfo-Register! Das Dateiinfo-Register erscheint nicht bei allen Dateitypen. Word-Dokumente bieten es an, einfache TextDokumente aber zum Beispiel nicht. Wenn Sie ein Word-Dokument zum ersten Mal speichern, also neu anlegen, dann besitzt es interessanterweise noch kein Dateiinfo-Register. Dieses Register erscheint erst dann, wenn Sie die Datei schließen, also nicht in Word anzeigen. Solange eine Datei in Gebrauch ist, verschwindet das Dateiinfo-Register!
Nun können Sie per Script herausfinden, welcher Autor ein bestimmtes Word-Dokument verfaßt hat – jedenfalls dann, wenn Sie Windows 2000 verwenden: ’ 6-11.vbs set FolderItem = GetItem("C:\BEISPIEL.DOC") Autor = FolderItem.ExtendedProperty("Author") MsgBox "Autor des Dokumentes: " & Autor function GetItem(pfad) ' pfadname und dateiname trennen, falls möglich if not right(pfad,1)="\" then dateiname = mid(pfad, InstrRev(pfad, "\")+1) if Instr(dateiname, ".")=0 then pfadname = pfad dateiname = "" else pfadname = left(pfad, InstrRev(pfad, "\")) end if else pfadname = pfad end if set shell = CreateObject("Shell.Application") set folder = shell.NameSpace(pfadname) if dateiname = "" then set GetItem = folder.self else set GetItem = folder.ParseName(dateiname) end if end function
Alle Autorennamen auflisten Das ist ausgesprochen nützlich. Vielleicht wollen Sie alle Winword-Dokumente auflisten, die von einer bestimmten Person stammen. Hier eine Lösung, die alle Winword-Dokumente im Ordner Eigene Dateien des aktuell angemeldeten Benutzers untersucht und dann die Namen der Autoren auflistet: ’ 6-12.vbs ’ Zugriff auf Dateien und Ordner via Shell: set shell = CreateObject("Shell.Application")
6.3
Der innere Aufbau des FolderItem-Objekts
147
' Speicher-Verzeichnis für Autorennamen: set dict = CreateObject("Scripting.Dictionary") ' Ordner "Eigene Dateien" öffnen ' Codenummer für Eigene Dateien lautet: 5 set folder = shell.NameSpace(5) ' alle Dateien in diesem Ordner auflisten: set folderitems = folder.items ' bisher gefunden: keine Dateien, keine Autoren: doccount = 0 authorcount = 0 ' alle Dateien untersuchen: for each folderitem in folderitems ' nur Winword-Dokumente berücksichtigen ' ist die Dateiextension "doc" ? if lcase(right(folderitem.path,3)) = "doc" then ' ja, DOC-Datei gefunden: doccount = doccount + 1 ' Autor auslesen: autor = FolderItem.ExtendedProperty("Author") ' ist Info verfügbar? if not autor = "" then ' ist dieser Autor schon in der Liste? if not dict.Exists(autor) then ' nein, aufnehmen! dict.Add autor, "dummy" authorcount = authorcount + 1 end if end if end if next ' Autorennamen ausgeben list = doccount & " DOC-Dateien gefunden, " & _ authorcount & " Autoren." & vbCr for each key in dict.keys list = list & key & vbCr next MsgBox list
Neu sind in diesem Beispiel zwei Dinge:
Erstens greift das Script nicht auf einen physischen Ordner zu, sondern auf einen der Windows-Spezialordner. Der Ordner Eigene Dateien kann je nach Windows-Installation an ganz unterschiedlichen Orten liegen. Das Script verwendet deshalb bei NameSpace keinen absoluten
148
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Pfad, sondern eine Codenummer. Die Codenummer 5 liefert immer das Folder-Objekt des Ordners Eigene Dateien zurück. Welche Codenummern es sonst noch gibt, verrät die Tabelle in Kapitel 6.2.3.
Zweitens verwendet das Script ein neues Objekt: Scripting.Dictionary. Es ist so etwas wie ein Mini-Nachschlagewerk. Das Script nutzt es, um darin die Autorennamen einzutragen. Der besondere Vorteil des Scripting.Dictionary-Objekts ist, daß dieses Objekt mit Exists blitzschnell prüfen kann, ob schon ein gleichnamiger Eintrag vorhanden ist. So wird jeder Autorenname nur ein einziges Mal gespeichert, auch wenn es viele Dokumente geben sollte, die aus der Feder dieses Autors stammen.
Bild 6.10: Dateien herausfischen, die von bestimmten Personen stammen
Herausfinden, welche Geheiminfos ein Dokument enthält Das Beispiel hat die Authors-Eigenschaft des Winword-Dokumentes verwendet. Woher weiß man aber, daß der Autorenname über Authors angesprochen wird, und welche weiteren Datei-Infos lassen sich über ExtendedProperty erreichen? Die folgende Tabelle verrät die Informationskategorien: Schlüsselwort
Bedeutung
Title (2) Subject (3) Author (4) Keywords (5) Comments (6) Template (7) Last Saved By (8) Revision Number (9) Total Editing Time (10) Last Printed (11) Create Time/Date (12) Last Saved Time/Date (13) Number of Pages (14) Number of Words (15) Number of Characters (16) Thumbnail (17) Name of Creating Application (18) Security (19)
Titel Thema Autor Stichwörter Kommentare Vorlage Zuletzt gespeichert von Revisionsnummer Gesamtbearbeitungszeit Zuletzt gedruckt am Erstellungsdatum Zuletzt gespeichert am Seitenzahl Wortanzahl Buchstabenzahl Vorschau Anwendung, die primär für das Erstellen dieses Dateityps zuständig ist Sicherheit
Tab. 6.3: Informationen, die in Dateien eingebettet werden können
6.3
Der innere Aufbau des FolderItem-Objekts
149
Allerdings hängt es von der Anwendung ab, Informationen in diesen Kategorien zu speichern. Die meisten Kategorien werden deshalb leer sein. Die Beispiele haben bisher die Eigenschaften direkt über ihren Namen erfragt. Das ist in Ordnung, aber nicht der effizienteste Weg. Vielseitiger ist, die gewünschte Information über ihre Kennzahl abzufragen. Diese Kennzahl heißt PID und ist in der Tabelle oben in Klammern angegeben. Neben der PID muß ExtendedProperty außerdem wissen, welche Informationsart Sie abfragen wollen (FMTID). Alle Eigenschaften aus der Tabelle oben stammen aus der Informationsart »Summary Information Property Set«. Sie werden gleich sehen, daß es noch eine ganze Reihe weiterer Geheimdetails gibt, auf die Ihr Script zugreifen kann. FMTID und PID ergeben zusammen die SCID, die eine Datei-Eigenschaft eindeutig festlegt. Schauen Sie sich an, wie Sie die Standardinformationen über die SCID erfragen. Die PID für den Autorennamen lautet genäß obiger Tabelle: 4. Die FMTID für die Standardeigenschaften heißt {F29F85E0-4FF9-1068-AB91-08002B27B3D9}. ’ 6-13.vbs set FolderItem = GetItem("C:\beispiel.doc") ' erste Variante: über Klartextnamen erfragen: name = folderitem.ExtendedProperty("Author") MsgBox "Autor: " & name ' zweite Variante: über PID erfragen: ' PID für Zeichenzahl: 16 ' ID für Summary Information: {F29F85E0-4FF9-1068-AB91-08002B27B3D9} fmtid = "{F29F85E0-4FF9-1068-AB91-08002B27B3D9}" pid = 4 scid = fmtid & "," & pid name = folderitem.ExtendedProperty(scid) MsgBox "Autor: " & name function GetItem(pfad) ' pfadname und dateiname trennen, falls möglich if not right(pfad,1)="\" then dateiname = mid(pfad, InstrRev(pfad, "\")+1) if Instr(dateiname, ".")=0 then pfadname = pfad dateiname = "" else pfadname = left(pfad, InstrRev(pfad, "\")) end if else pfadname = pfad end if set shell = CreateObject("Shell.Application")
150
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
set folder = shell.NameSpace(pfadname) if dateiname = "" then set GetItem = folder.self else set GetItem = folder.ParseName(dateiname) end if end function
Noch mehr Geheiminformationen entdecken ExtendedProperty unterstützt in Wirklichkeit sehr viel mehr Informationskategorien als die, die im Summary-Report einer DOC-Datei angezeigt werden. Hier die Liste der unterstützten Kategorien (FMTIDs): FMTID
Beschreibung
{F29F85E0-4FF9-1068-AB91-08002B27B3D9} {B725F130-47EF-101A-A5F1-02608C9EEBAC} {28636AA6-953D-11D2-B5D6-00C04FD918D0} {9B174B33-40FF-11D2-A27E-00C04FC30871} {9B174B34-40FF-11D2-A27E-00C04FC30871} {9B174B35-40FF-11D2-A27E-00C04FC30871} {49691C90-7E17-101A-A91C-08002B2ECDA9}
Standardeigenschaften (siehe Tabelle oben) Storage-Eigenschaften Shell-Details Papierkorb-Details Verschiedenes-Eigenschaften Volume-Eigenschaften Abfrage-Eigenschaften
Tab. 6.4: IDs für erweiterte Datei-Informationen
Die Storage-Eigenschaften beleuchten Details aus der Sicht des Dateisystems: PID 4 10 12 13 14
Objekt-Typ Angezeigter Objekt-Name Objekt-Größe Attribute Datum der letzten Änderung
Tab. 6.5: Storage-Eigenschaften einer Datei
So setzen Sie diese Informationen ein: ’ 6-14.vbs set FolderItem = GetItem("C:\beispiel.doc") ’ wir sind an Storage-Informationen interessiert: fmtid = "{B725F130-47EF-101A-A5F1-02608C9EEBAC}" name = CStr(FolderItem.ExtendedProperty(fmtid & ",10")) typ = CStr(FolderItem.ExtendedProperty(fmtid & ",4"))
6.3
Der innere Aufbau des FolderItem-Objekts
151
' Variablentyp wird von VBScript nicht unterstützt 'size = TypeName(FolderItem.ExtendedProperty(fmtid & ",12")) attribs = CStr(FolderItem.ExtendedProperty(fmtid & ",13")) writetime = CStr(FolderItem.ExtendedProperty(fmtid & ",14")) msg = name & vbCr & typ & vbCr & size & vbCr & attribs & vbCr & writetime MsgBox msg
function GetItem(pfad) ' pfadname und dateiname trennen, falls möglich if not right(pfad,1)="\" then dateiname = mid(pfad, InstrRev(pfad, "\")+1) if Instr(dateiname, ".")=0 then pfadname = pfad dateiname = "" else pfadname = left(pfad, InstrRev(pfad, "\")) end if else pfadname = pfad end if set shell = CreateObject("Shell.Application") set folder = shell.NameSpace(pfadname) if dateiname = "" then set GetItem = folder.self else set GetItem = folder.ParseName(dateiname) end if end function
Ausgerechnet die Size-Eigenschaft, die die Objektgröße angibt, kann auf diese Weise nicht erfragt werden. Windows liefert die Größe in einem Variablenformat zurück, das von VBScript nicht verstanden wird.
Bild 6.11: Detailinfos über beliebige Dateien erfragen
Insgesamt erfragen Sie die Dateisystem-Informationen besser über GetDetailsOf. Diese Funktion ist nicht nur einfacher zu handhaben, sondern sie funktioniert auch bei anderen Windows-Versionen und liefert die Dateigröße korrekt zurück.
152
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Shell-Details: Spezialisteninformationen Wer ganz besonders detailreiche Informationen über die Art eines Objekts wünscht, kann die Shell-Details erfragen. Die Shell-Details beantworten zum Beispiel die Frage, ob es sich bei dem FolderItem-Objekt um eine Datei, einen Ordner, ein Laufwerk oder gar ein virtuelles Objekt handelt. Allerdings wird spätestens hier klar, wo die Grenzen des Scripting liegen. Das Ergebnis dieser Abfrage ist nämlich ein Binärobjekt, und mit Binärobjekten kann der WSH eigentlich nicht umgehen. Bei Windows 2000 gibt es jedoch ein weiteres COM-Objekt namens ixsso.util, das eigentlich Teil des Index Servers ist. Dieses Objekt kann dazu mißbraucht werden, Binärdaten auszulesen. So funktioniert die Sache: ’ 6-15.vbs set shell = CreateObject("Shell.Application") set util = CreateObject("ixsso.Util") ’ erster Test: eine Datei set item = shell.NameSpace("C:\").ParseName("AUTOEXEC.BAT") MsgBox FindType(item) ’ zweiter Test: virtueller Ordner set item = shell.NameSpace(3).self MsgBox FindType(item) ’ dritter Test: ein Laufwerk set item = shell.NameSpace("C:\").self MsgBox FindType(item) ’ vierter Test: ein Netzwerkshare ' funktioniert natürlich nur, wenn dieser Netzwerkpfad existiert! set item = shell.NameSpace("\\win98\c").self MsgBox FindType(item) function FindType(folderitem) ' Klartextnamen der Typ-Kennzahlen codes = ",virt. Root,Datei,Verzeichnis,Anderes,3 1/2 Disk," _ & "5 1/4 Disk,Wechselplatte,Festplatte,Netzlaufwerk," _ & "CD-ROM,RAM-Disk,Anderes Laufwerk,Domäne,Server," _ & "Share,Netzwerk,," ' in ein Variablenfeld übertragen: ' codearray(2) steht jetzt z.B. für "Datei" codearray = Split(codes,",") ' wir sind an Storage-Informationen interessiert: fmtid = "{28636AA6-953D-11D2-B5D6-00C04FD918D0}" ' Binärdaten auslesen binary = folderitem.ExtendedProperty(fmtid & ",2") ' erstes Byte aus Binärdaten auslesen: typeid = util.GetArrayElement(binary,0)
6.3
Der innere Aufbau des FolderItem-Objekts
153
' Klartextname des FolderItem-Objekts zurückgeben FindType = codearray(typeid) end function
Sicher werden Sie zustimmen, daß dieses Script tief in die technische Trickkiste greifen muß, um die Typ-Informationen sinnvoll lesbar anzuzeigen. Dennoch: Auch dieses Script kann in vielen Fällen die entscheidenden Informationen liefern und ist nicht nur Extrem-Scriptfummeling.
Den Besitzer einer Datei ermitteln Die Verschiedenes-Eigenschaften sind in Spezialfällen ebenfalls interessant. Sie melden nämlich den Besitzer einer Datei zurück. Das spielt natürlich nur dann eine Rolle, wenn Sie Dateien auf einem Laufwerk mit NTFS-Dateisystem unter die Lupe nehmen, denn nur dort gibt es überhaupt Besitzrechte und Schließanlagen.
Bild 6.12: Die Besitzrechte von Dateien und Ordnern klären
Das nächste Script zeigt, wie Sie die Besitzer aller Dateien und Ordner im Laufwerk D:\ bestimmen – vorausgesetzt, es benutzt das NTFS-Dateisystem. Beim FAT-Dateisystem meldet das Script bei jedem Eintrag als Besitzer »Jeder«. Stören Sie sich nicht daran, daß das Dialogfenster vermutlich für das Ergebnis zu klein ist und mittendrin die Ausgabe abbricht. Sie könnten die Information ebenso gut direkt in eine Textdatei (Kapitel 4) oder eine Datenbank (Kapitel 9) schreiben. ’ 6-16.vbs set shell = CreateObject("Shell.Application") ’ auf Papierkorb zugreifen set folder = shell.NameSpace("D:\") set folderitems = folder.items fmtid = "{9B174B34-40FF-11D2-A27E-00C04FC30871}" if folderitems.Count>0 then for each folderitem in folderitems besitzer = (folderitem.ExtendedProperty(fmtid & ",4"))
154
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
list = list & folderitem.name & _ ": Besitzer ist " & besitzer & vbCr next end if MsgBox list, vbInformation
6.3.2
GetFolder
Property GetFolder As Object
Handelt es sich bei dem FolderItem selbst um einen Ordner, also einen Unterordner im aktuellen Ordner, dann liefert GetFolder das betreffende Folder-Objekt. Bevor Sie GetFolder einsetzen, sollten Sie als erstes mit isFolder prüfen, ob das FolderItem-Objekt tatsächlich ein Ordner ist. Mit GetFolder lassen sich verschachtelte Ordner rekursiv durchsuchen. Rekursiv bedeutet: Stößt Ihr Script in einem Ordner auf einen Unterordner, so ruft es sich für diesen Unterordner erneut auf und kann so alle Dateien finden, auch die, die in tief verschachtelten Ordnern liegen. Das folgende Script durchsucht beispielsweise rekursiv den Stammordner C:\ und legt eine Liste aller gefundenen Textdateien an: ’ 6-17.vbs set shell = CreateObject("Shell.Application") set folder = shell.NameSpace("C:\") ’ Ausgabedatei anlegen set fs = CreateObject("Scripting.FileSystemObject") dateiname = "C:\logbuch.txt" set liste = fs.CreateTextFile(dateiname, true) ’ Ordner C:\ rekursiv nach TXT-Dateien durchsuchen OrdnerDurchsuchen folder ' Ausgabedatei schließen und öffnen liste.close set wshshell = CreateObject("WScript.Shell") wshshell.Run dateiname sub OrdnerDurchsuchen(folderobject) ' Inhalt des Ordners ansehen set folderitems = folderobject.items for each folderitem in folderitems ' ist der Eintrag selbst ein Ordner? if folderitem.isFolder then ' ja, dann diesen Ordner auch durchsuchen OrdnerDurchsuchen folderitem.GetFolder ' ist Datei eine Textdatei? elseif lcase(right(folderitem.path,3))="txt" then ' ja, dann in Liste einfügen AddToList folderitem.path
6.3
Der innere Aufbau des FolderItem-Objekts
155
end if next end sub sub AddToList(text) liste.WriteLine text end sub
Diese umfangreiche Suchaktion kann allerdings mehrere Minuten dauern. Während dieser Zeit sieht und hört der Anwender nichts vom Script und könnte dem frevelhaften Gedanken verfallen, das Script hätte sich aufgehängt. Bei solch langwierigen Operationen ist es deshalb sinnvoll, eine Fortschrittsanzeige einzublenden. Wie dies gelingt, ist in Kapitel 8.16.1 beschrieben. Schauen Sie sich auch das Scripting.FileSystemObject aus Kapitel 4 an: es ist ebenfalls in der Lage, das Dateisystem rekursiv zu durchsuchen. Im Gegensatz zu Shell.Application ist es auf jedem Computer mit WSH vorhanden. Shell.Application fehlt auf Windows 95 und -NT, wenn dort nicht der Internet Explorer 4 nachgerüstet wurde.
6.3.3
GetLink
Property GetLink As Object
GetLink liefert ein ShellLinkObject zurück, das eine Verknüpfung repräsentiert. Handelt es sich beim FolderItem um eine Verknüpfung, dann können Sie auf diese Weise in die Verknüpfung »hineinsehen« und zum Beispiel herausfinden, wo das Ziel der Verknüpfung liegt und ob Tastenshortcuts eingerichtet wurden. Neue Verknüpfungen lassen sich allerdings auf diese Weise nicht anlegen (mit einem kleinen Trick allerdings schon, siehe unten). Wenn Sie nicht auf die besonderen Funktionen von Shell.Application angewiesen sind, dann verwenden Sie besser das Wscript.Shell-Objekt, um Verknüpfungen zu managen (mehr dazu im Vorgängerband: Franzis’ Professional Series Scripting Host Praxisbuch). Es eignet sich besser, weil es auf jedem Computer mit WSH installiert ist und außerdem auch neue Verknüpfungen ins Leben rufen kann. Das folgende Script sucht auf dem Desktop nach der Verknüpfung willibald.lnk. Legen Sie sich solch eine Verknüpfung auf Ihren Desktop, und probieren Sie dann das Script aus: ’ 6-18.vbs set shell = CreateObject("Shell.Application") ’ Zugang zum Desktop bekommen set folder = shell.NameSpace(0) ' Zugang zur Verknüpfung bekommen ' Errorhandling ausschalten, um prüfen zu können, ' ob die Datei wirklich existiert on error resume next set folderitem = folder.ParseName("willibald.lnk") if not err.number=0 then
156
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
MsgBox "Legen Sie zuerst auf Ihrem Desktop eine " _ & "Verknüpfung namens ""willibald.lnk"" an!" WScript.Quit end if on error goto 0 ' Zugang zum ShellLinkObject bekommen set linkobject = folderitem.GetLink ' Ziel des Links ausgeben: MsgBox linkobject.Path
Welche Funktionen und Möglichkeiten das ShellLinkObject sonst noch zu bieten hat, verrät Ihnen der Scripting Spy.
6.3.4
InvokeVerb
Sub InvokeVerb([ByVal vVerb])
Dieser Befehl ist ausgesprochen mächtig, gibt er Ihnen doch volle Kontrolle über das Kontextmenü des FolderItems. Damit wird es möglich, Dateien zu öffnen und Anwendungen zu starten. InvokeVerb ruft einen beliebigen Befehl aus dem Kontextmenü des Objekts auf. Wird kein besonderer Befehl angegeben, dann ruft InvokeVerb den Standardbefehl auf. Das nächste Script öffnet zum Beispiel auf dem Desktop die Datei test.txt. Legen Sie sich diese Datei auf den Desktop, und probieren Sie dann das Script aus: ’ 6-19.vbs set shell = CreateObject("Shell.Application") ’ Zugang zum Desktop bekommen set folder = shell.NameSpace(0) ’ Zugang zur Datei bekommen ' Errorhandling ausschalten, um prüfen zu können, ' ob die Datei wirklich existiert on error resume next set folderitem = folder.ParseName("test.txt") if not err.number=0 then MsgBox "Legen Sie zuerst auf Ihrem Desktop eine " _ & "Textdatei namens ""test"" an!" WScript.Quit end if on error goto 0 folderitem.InvokeVerb MsgBox "Datei wurde geöffnet", vbSystemModal
Klicken Sie die Testdatei test.txt auf Ihrem Desktop nun mit der rechten Maustaste an: Das Kontextmenü wird sichtbar. Ihr Script hat daraus den fettgedruckten Standardbefehl aufgerufen, weil
6.3
Der innere Aufbau des FolderItem-Objekts
157
Sie keinen speziellen Befehl angegeben haben. Ebensogut könnten Sie nun jeden anderen Kontextmenü-Befehl aufrufen. Wenn Sie die Datei beispielsweise ausdrucken möchten, dann verwenden Sie den Drucken-Befehl: ’ 6-20.vbs set shell = CreateObject("Shell.Application") set folder = shell.NameSpace(0) set folderitem = folder.ParseName("test.txt") folderitem.InvokeVerb "&Drucken"
Hierbei lauert allerdings die Tücke im Detail: Damit InvokeVerb Ihren Befehl verstehen kann, müssen Sie ihn exakt so angeben, wie er im Kontextmenü erscheint. Auch der Unterstrich, mit dem Windows im Befehlsnamen einzelne Buchstaben unterlegt, gehört zum Namen. Weil auf meinem Testsystem der Buchstabe »D« des Drucken-Befehls mit einem Unterstrich markiert ist, muß vor diesem Buchstaben ein kaufmännisches &-Zeichen gesetzt werden. Klar wird, daß damit der Einsatzbereich von InvokeVerb eingeschränkt ist: Woher sollen Sie wissen, wie die Kontextmenü-Befehle auf dem Rechner eines Kunden heißen, der Ihr Script benutzen soll? Glücklicherweise gibt es einige Auswege. So können Sie sich mit Verbs eine Liste der KontextmenüBefehle ausgeben lassen, die das FolderItem-Objekt unterstützt. Leider funktioniert diese Variante erst bei Windows 2000 fehlerfrei. Bei Windows 9x und NT liefert Verbs ein falsches Objekt zurück, und es kommt zu einem Fehler: ’ 6-21.vbs ’ funktioniert nur bei Windows 2000! set shell = CreateObject("Shell.Application") set folder = shell.NameSpace(0) set folderitem = folder.ParseName("test.txt") set folderitemverbs = folderitem.Verbs for each folderitemverb in folderitemverbs list = list & folderitemverb & vbCr next MsgBox list
Eine andere Möglichkeit sind Standardnamen. Windows verwendet intern für das Öffnen den Befehl »open«, für das Drucken den Befehl »print«. Alternativ zu den »echten« KontextmenüNamen können Sie also auch einen dieser standardisierten Namen angeben. Leider funktionieren die Standardnamen erst bei Windows 2000. Tip: So funktionieren die Standardnamen in Wirklichkeit Grundsätzlich kann ein Kontextmenü-Befehl zwei Namen haben: Den ersten bekommt er über den Schlüsselnamen in der Registry, also dort, wo sein Innenleben definiert wird. Wird hier als Name ein Standard wie open oder print angegeben, dann nennt Windows den Befehl automatisch in der jeweiligen Landessprache zum Beispiel »Öffnen« oder »Drucken«. Auf Wunsch kann dem (Standard-)Eintrag des Befehls aber auch ein abweichender Name gegeben werden.
158
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Der ersetzt dann den Standardnamen im Kontextmenü. Bisher mußte InvokeVerb mit diesem abweichenden Namen oder – falls keiner angegeben ist – mit der »Übersetzung« des Standardnamens gefüttert werden. Seit Windows 2000 kann nun auch der Standardname selbst angegeben werden – wesentlich besser.
Auch wenn Sie auf Ihrem System die Kontextmenü-Befehlsnamen nicht eindeutig bestimmen können, ist InvokeVerb ausgesprochen nützlich. Erstens können Sie es jederzeit ohne Argument verwenden (siehe oben), und zweitens sind einige Befehlsnamen weitestgehend standardisiert.
Bild 6.13: Scriptgesteuert Eigenschaften-Dialoge kontrollieren
Das nächste Script öffnet beispielsweise die Eigenschaften-Seite einer Datei, die Sie auf das ScriptIcon ziehen. Ist diese Datei eine Verknüpfung, dann wird statt dessen die Eigenschaften-Seite der Originaldatei geöffnet – also nicht die uninteressante Eigenschaften-Seite der Verknüpfung. ’ 6-22.vbs ’ Argument einlesen set args = WScript.Arguments if args.count=0 then MsgBox "Ziehen Sie eine Datei auf mich!" WScript.Quit end if ' Pfad- und Dateinamen auseinanderdröseln pfad = left(args(0),InstrRev(args(0), "\")) datei = mid(args(0),InstrRev(args(0), "\")+1) ' hin zur Datei:
6.3
Der innere Aufbau des FolderItem-Objekts
159
set shell = CreateObject("Shell.Application") set folder = shell.NameSpace(pfad) set folderitem = folder.ParseName(datei) ' ist die Datei etwa eine Verknüpfung? if folderitem.isLink then ' ja, also Eigenschaften öffnen ' und dann das Ziel finden folderitem.InvokeVerb "E&igenschaften" set linkobj = folderitem.GetLink ziel = linkobj.Path pfad = left(ziel,InstrRev(ziel, "\")) datei = mid(ziel,InstrRev(ziel, "\")+1) set folder = shell.NameSpace(pfad) set folderitem = folder.ParseName(datei) ' jetzt steht in folderitem das Ziel des Links end if ' alles klar, Eigenschaften öffnen: folderitem.InvokeVerb "E&igenschaften" ' Verzögern (5 sec) WScript.Sleep 5000 MsgBox "Eigenschaften schließen?", vbQuestion + vbSystemModal
Das Script funktioniert sowohl mit Dateien als auch mit Ordnern und öffnet tatsächlich die Eigenschaften-Seite der Datei, die Sie auf das Script gezogen haben. Ziehen Sie testweise eine Verknüpfung auf das Script! Diesmal werden sogar zwei Eigenschaften-Fenster geöffnet: das der Verknüpfung, und vollautomatisch auch das der Datei, auf die die Verknüpfung weist. Allerdings wird auch der Aufräumwahn des WSH sichtbar: Das Script läuft noch 5 Sekunden länger als nötig, um den Eigenschaften-Fenstern Zeit zu geben, sichtbar zu werden. Anschließend fragt es scheinheilig nach, ob die Eigenschaften-Fenster geschlossen werden sollen. Eine Alternative gibt es aber gar nicht: Alles, was Ihr Script während seiner Ausführung anstellt, wird automatisch geschlossen, sobald das Script endet. Das gilt auch für die Eigenschaften-Fenster, die nur so lange sichtbar bleiben, wie Ihr Script läuft. Sobald Sie also auf OK klicken, beendet das Script seine Arbeit, und auch die Eigenschaften-Fenster machen Feierabend.
6.3.5
InvokeVerbEx
Sub InvokeVerbEx([ByVal vVerb], [ByVal vArgs])
InvokeVerbEx ist der große Bruder von InvokeVerb und nur bei Windows 2000 anzutreffen. Im Gegensatz zu InvokeVerb kann InvokeVerbEx noch ein zweites Argument lesen (vArgs) und verwendet dieses für zusätzliche Argumente, die Sie dem Kontextmenü-Befehl überreichen wollen.
160 6.3.6
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
IsBrowsable
Property IsBrowsable As Boolean
Liefert Wahr zurück, wenn das FolderItem-Objekt ein Container ist, der als eigener NameSpace fungiert und Objekte enthält.
6.3.7
IsFileSystem
Property IsFileSystem As Boolean
Liefert Wahr zurück, wenn das FolderItem-Objekt Teil des lokalen Dateisystems ist, also eine Datei, ein Ordner oder ein Laufwerk.
6.3.8
IsFolder
Property IsFolder As Boolean
Liefert Wahr zurück, wenn das FolderItem-Objekt ein Ordner ist. Mit GetFolder erhalten Sie dann das Folder-Objekt dieses Ordners.
6.3.9
IsLink
Property IsLink As Boolean
Liefert Wahr zurück, wenn das FolderItem-Objekt eine Verknüpfung ist. Mit GetLink erhalten Sie dann das ShellLinkObject mit den Details der Verknüpfung.
6.3.10 ModifyDate Property ModifyDate As Date
Liefert das Datum der letzten Änderung zurück.
6.3.11 Name Property Name As String
Liefert den Namen des Objekts zurück, und zwar so, wie er augenblicklich von Windows angezeigt würde. Haben Sie den Explorer beispielsweise so eingestellt, daß er Dateiextensionen verschluckt, dann liefert Name den Dateinamen ebenfalls ohne Extension. Den echten Pfadnamen eines Dateisystem-Objekts liefert Path zurück.
6.4
Der innere Aufbau des Folder-Objekts
161
6.3.12 Parent Property Parent As Object
Verknüpfung zum übergeordneten Objekt.
6.3.13 Path Property Path As String
Der Pfadname zu diesem Objekt, so wie er vom Explorer verstanden wird. Bei virtuellen Ordnern liefert Windows 2000 automatisch die GUIDs zurück, bei Windows 9x und NT wird statt dessen ein Leerstring gemeldet.
6.3.14 Size Property Size As Long
Größe des Objekts in Byte.
6.3.15 Type Property Type As String
Typenbezeichnung des Objekts, zum Beispiel »Microsoft Word-Dokument«.
6.3.16 Verbs Function Verbs As FolderItemVerbs
Liefert eine Liste aller Kontextmenü-Befehle zurück, die dieses Objekt anzubieten hat. Ein Beispiel hierzu finden Sie bei InvokeVerb. Leider liefert Verbs bei Windows 9x und NT eben nicht wie erwartet ein FolderItemVerbs-Objekt zurück, sondern aufgrund eines Bugs ein FolderItemVerbObjekt. Deshalb ist diese Funktion erst bei Windows 2000 zu gebrauchen.
6.4
Der innere Aufbau des Folder-Objekts
Mit FolderItem-Objekten kennen Sie sich inzwischen gut aus. Alle FolderItem-Objekte sind immer Bewohner eines Folder-Objekts. Das Folder-Objekt entspricht also dem Container, der die FolderItem-Objekte beherbergt und wichtige Rahmenfunktionen bietet. Oder anders gesagt: Das FolderObjekt könnte einem Ordner entsprechen, und die Dateien im Ordner werden über FolderItemObjekte repräsentiert. So sieht das Folder-Objekt von innen aus:
162
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Methode/Eigenschaft
Beschreibung
Application CopyHere DismissedWebViewBarricade GetDetailsOf HaveToShowWebViewBarricade Items MoveHere NewFolder OfflineStatus Parent ParentFolder ParseName
Die Applikation, die den Folder darstellt Kopiert Objekte in den Ordner (5.0) Web View Barricade wurde vom Benutzer abgeschaltet Ermittelt Details über ein FolderItem-Objekt im Ordner (5.0) Legt fest, ob die Web View Barricade angezeigt wird Liefert den Ordnerinhalt als FolderItems-Objekt zurück Verschiebt Objekte in den Ordner Legt einen Unterordner im Ordner an (5.0) Legt fest, ob der Ordner offline angezeigt wird Liefert das übergeordnete Objekt zurück Liefert übergeordneten Ordner als Folder-Objekt Liefert ein FolderItem-Objekt zurück, das dem angegebenen Namen entspricht (5.0) Referenz auf das FolderItem-Objekt, das dem Ordner entspricht (5.0) Synchronisiert alle Offline-Folder Titeltext des Ordners
Self Synchronize Title
Tab. 6.6: Das Innenleben eines Folder-Objekts
6.4.1
Application
Property Application As Object
Liefert das Objekt zurück, das dieses Folder-Objekt verwendet. Dies ist immer eine Referenz auf das Shell.Application-Objekt. ’ 6-23.vbs set Shell = CreateObject("Shell.Application") set folder = Shell.BrowseForFolder(0, _ "Suchen Sie sich einen Ordner aus",0,"C:\") set obj = folder.Application MsgBox TypeName(obj)
6.4.2
CopyHere
Sub CopyHere(ByVal vItem, [ByVal vOptions])
Kopiert eine oder mehrere Dateien in diesen Ordner. Dabei zeigt Windows sein offizielles Dialogfenster, wenn die Kopieraktion länger dauert. CopyHere kann sowohl mit FolderItem-Objekten arbeiten als auch mit Klartext-Pfadnamen. Es akzeptiert sogar Joker. Das folgende Script kopiert alle Textdateien aus dem Stammordner C:\ in den Ordner C:\TXTFILES und zeigt dabei sein Dialogfenster an, falls die Kopieraktion länger dauern sollte. Achten Sie darauf, daß Sie den Ordner C:\TXTFILES angelegt haben und daß es im Ordner C:\ auch tatsächlich einige TXT-Dateien gibt, die das Script kopieren kann:
6.4
Der innere Aufbau des Folder-Objekts
163
’ 6-24.vbs set shell = CreateObject("Shell.Application") set folder = shell.NameSpace("C:\TXTFILES") if TypeName(folder)="Nothing" then MsgBox "Bitte legen Sie den Ordner C:\TXTFILES an!" WScript.Quit end if folder.CopyHere "c:\*.TXT" MsgBox "Erledigt."
Rufen Sie das Script ein zweites Mal auf, dann erleben Sie eine weitere Überraschung: Anders als bei den Kopiermethoden des Scripting.FileSystemObject wird diesmal nachgefragt, ob die schon existierenden Dateien überschrieben werden sollen.
Bild 6.14: Shell.Application fragt nach, ob überschrieben werden soll
Auch FolderItems können an CopyHere übergeben werden: ’ 6-25.vbs set shell = CreateObject("Shell.Application") set wshshell = CreateObject("WScript.Shell") windir = wshshell.ExpandEnvironmentStrings("%WINDIR%") set origfolder = shell.NameSpace(windir) set destfolder = shell.NameSpace("C:\TXTFILES") for each item in origfolder.items if lcase(right(item.path,3))="txt" then destfolder.CopyHere item end if next MsgBox "Erledigt."
164
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Weil hier allerdings die einzelnen Dateien in eigenständigen Häppchen an CopyHere verfüttert werden, erscheint die Fortschrittsanzeige nicht oder nur kurz für jede einzelne Datei. Weiteres Manko: Die Fehlermeldungen von CopyHere sind grob irreführend.
Bild 6.15: Die Fehlermeldungen sind grob irreführend – es gibt deshalb bessere Wege
All diese Hemmnisse fegen Sie beiseite, wenn Sie nicht via Shell.Application und CopyHere auf die eingebaute Kopierstation von Windows zugreifen, sondern direkt. Dann nämlich haben Sie die Wahl, auch viele verschiedene Dateien aus einer Liste heraus mit Fortschrittsanzeige zu kopieren. Mehr dazu lesen Sie in Kapitel 8.25.
6.4.3
DismissedWebViewBarricade
Sub DismissedWebViewBarricade
Für Scripts ungeeignet, interne Bedeutung. Neues Feature von Windows 2000.
6.4.4
GetDetailsOf
Function GetDetailsOf(ByVal vItem, ByVal iColumn As Empty) As String
Liefert zusätzliche Informationen zu einem FolderItem-Objekt wie seine Größe oder seine DateiAttribute. Codezahl
Bedeutung
-1 0 1 2 3 4
InfoTip-Text (nicht bei jedem Dateityp vorhanden) Name Größe Typ Datum der letzten Änderung Attribute
Tab. 6.7: Die Grundinformationstypen werden auf allen Windows-Versionen unterstützt
Das folgende Script zeigt, wie Sie mit GetDetailsOf die Detailinformationen einer Datei lesen: ’ 6-26.vbs set shell = CreateObject("Shell.Application")
6.4
Der innere Aufbau des Folder-Objekts
165
set folder = shell.NameSpace("C:\") set folderitem = folder.ParseName("msdos.sys") for x = -10 to 50 beschreibung = folder.GetDetailsOf(vbNull, x) inhalt = folder.GetDetailsOf(folderitem, x) if not (beschreibung = "" and inhalt = "") then list = list & x & ": " & beschreibung & " = " _ & inhalt & vbCr end if next MsgBox list
Hier sind gleich mehrere Dinge verblüffend: Erstens liefert das Dialogfenster nicht nur den Inhalt der einzelnen Kategorien, sondern auch den Namen der Kategorie. Sie haben nämlich zwei Möglichkeiten, GetDetailsOf aufzurufen: Entweder geben Sie ein FolderItem-Objekt an. Dann liefert die Funktion den Informationswert, den Sie anfordern. Oder Sie geben als FolderItem-Objekt vbNull an. In diesem Fall liefert die Funktion den Namen der Kategorie, also zum Beispiel »Dateiname«, »Größe« oder »Typ«.
Bild 6.16: Universell einsetzbar: Informationen über Dateien erfragen
Und zweitens liefert das Script bei Ihnen möglicherweise weitaus mehr Informationen zurück als oben in Tabelle 6.7 angegeben. Bei Windows 2000 ist GetDetailsOf wesentlich schlauer geworden und meldet viele zusätzliche Dateiinformationen: Codezahl
Beschreibung
5 6 7 8 10 11 12 13 14 15 16 17
Kommentar Erstellt Letzter Zugriff Eigentümer Autor Titel Thema Kategorie Seiten Copyright Name der Firma Modulbeschreibung
166
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Codezahl
Beschreibung
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
Modulversion Produktname Produktversion Sendername Empfängername Empfängernummer CSID TSID Sendezeit Anruferkennung Routing Audioformat Exemplarrate Größe des Audioexemplars Kanäle Spiellänge Rahmenzähler Rahmenrate Größe des Videoexemplars Videokomprimierung
Tab. 6.8: Windows 2000 bietet weitaus mehr Informationen an
Das nächste Script schaut in Ihren Ordner Eigene Dateien und listet danach alle Winword-Texte und die Zahl der Seiten darin auf – was wie gesagt nur bei Windows 2000 funktioniert. ’ 6-27.vbs set shell = CreateObject("Shell.Application") ’ Zugriff auf Eigene Dateien set folder = shell.NameSpace(5) ’ Inhalt untersuchen for each folderitem in folder.Items ’ ist es eine DOC-Datei (Winword) ? if lcase(right(folderitem.path, 3)) = "doc" then ’ ja, Seitenanzahl ermitteln seitenzahl = folder.GetDetailsOf(folderitem, 14) liste = liste & seitenzahl & " Seite(n): " _ & folderitem.name & vbCr end if next MsgBox liste
Ebenso einfach könnten Sie nach Autorennamen, nach Besitzer oder anderen Kriterien Listen zusammenstellen – oder via CopyHere ganz bestimmte Dokumente automatisch in einen Sicherungs-
6.4
Der innere Aufbau des Folder-Objekts
167
ordner kopieren. Denken Sie aber daran: Diese neuen Informationsquellen gibt es nur bei Windows 2000. Wie vielseitig GetDetailsOf ist, zeigt auch das nächste Script. Es verbindet sich mit dem Systemordner von Windows und erstellt eine Liste der DLL-Bibliotheken samt Versionsnummer und Beschreibung. Dieser Vorgang kann einige Minuten dauern – bitte Geduld! ’ 6-28.vbs set shell = CreateObject("Shell.Application") set fs = CreateObject("Scripting.FileSystemObject") ’ Ergebnisdatei anlegen dateiname = "C:\LOGBUCH.TXT" set datei = fs.CreateTextFile(dateiname, true) datei.WriteLine "Dateiname" & vbTab & "Version" _ & vbTab & "Beschreibung"
’ Zugriff auf Systemordner set folder = shell.NameSpace(37) ’ Inhalt untersuchen for each folderitem in folder.Items ’ ist es eine DLL-Datei? if lcase(right(folderitem.path, 3)) = "dll" then ’ ja, Infos erfragen beschreibung = folder.GetDetailsOf(folderitem, 17) version = folder.GetDetailsOf(folderitem, 18) info = folderitem.name & vbTab & version & vbTab _ & beschreibung datei.WriteLine info end if next datei.close ' Ergebnisdatei mit den reinen Mitteln des Shell.Application-Objekts öffnen: set folder = shell.NameSpace("C:\") set folderitem = folder.ParseName("LOGBUCH.TXT") folderitem.InvokeVerb
Besonders interessant am Rande: Das Script öffnet nach seiner Arbeit zuvorkommend die Textdatei mit den gesammelten Daten. Dazu verwendet es InvokeVerb (siehe oben).
168
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Bild 6.17: Informationen über DLLs in Ihrem System
6.4.5
HaveToShowWebViewBarricade
Property HaveToShowWebViewBarricade As Boolean
Neue Funktion von Windows 2000, die für Scripts ohne Bedeutung ist.
6.4.6
Items
Function Items As FolderItems
Items liefert den gesamten Ordnerinhalt zurück. Das Ergebnis ist ein FolderItems-Objekt, das die einzelnen Objekte des Ordners als FolderItem-Objekte enthält. Sie können mit for each...next das FolderItems-Objekt auslesen. Items wird in diesem Kapitel ständig eingesetzt. Eine grundlegende Einführung in die Objekte und wie sie zusammengehören finden Sie am Kapitelanfang.
6.4.7
MoveHere
Sub MoveHere(ByVal vItem, [ByVal vOptions])
Funktioniert wie CopyHere, nur wird die Datei nicht kopiert, sondern verschoben.
6.4
6.4.8
Der innere Aufbau des Folder-Objekts
169
NewFolder
Sub NewFolder(ByVal bName As String, [ByVal vOptions])
Legt in einem Ordner einen Unterordner an. Geben Sie den Namen des Unterordners an. Die Optionen brauchen nicht angegeben zu werden und sind bislang auch noch ohne Bedeutung.
6.4.9
OfflineStatus
Property OfflineStatus As Long
Meldet, ob ein Ordner offline oder online ist. Lokale Ordner sind natürlich immer online, aber Windows 2000 bringt ein neues Feature namens »Offline Folder« mit. Damit ist es möglich, Netzwerkordner auch dann noch zu erreichen, wenn das Netzwerk gerade nicht vorhanden ist – zum Beispiel unterwegs oder bei einem Netzwerkausfall. OfflineStatus verrät Ihnen, ob ein Ordner offline verfügbar ist und wie sein Status aussieht: ’ 6-29.vbs set shell = CreateObject("Shell.Application") ’ einen Ordner herauspicken set folder = shell.NameSpace("\\win98\c\ordnerxy") MsgBox folder.offlineStatus
Vorausgesetzt, der Netzwerkpfad existiert und Sie verwenden Windows 2000, liefert OfflineStatus nun einen der folgenden Werte zurück: Rückgabewert
Bedeutung
-1 0 1 2
Ordner ist nicht offline verfügbar Ordner ist offline verfügbar und derzeit online Ordner ist offline verfügbar und derzeit offline; es wird also die lokale Kopie verwendet Ordner ist zwar offline, aber der Server ist wieder online (das Netzwerk ist wieder verfügbar). Der Ordner kann also wieder online geschaltet werden. Es wurde in den Onlinebetrieb zurückgewechselt, ohne daß Änderungen in der lokalen Kopie synchronisiert wurden. Online- und Offline-Ordner unterscheiden sich also, und eine Synchronisierung ist dringend geboten.
3
Tab. 6.9: Informationen über den Status von Offline-Foldern (Windows 2000)
6.4.10 Parent Property Parent As Object
Liefert das übergeordnete Objekt zurück.
170
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
6.4.11 ParentFolder Property ParentFolder As Folder
Liefert den Ordner als Folder-Objekt zurück, in dem der aktuelle Ordner beherbergt wird.
6.4.12 ParseName Function ParseName(ByVal bName As String) As FolderItem
ParseName übersetzt herkömmliche Dateisystem-Pfadnamen in die Shell-Bezeichnung und liefert dann das betreffende FolderItem-Objekt zurück. Um also auf eine Datei zuzugreifen, besorgen Sie sich zuerst mit NameSpace den Ordner, in dem die Datei liegt. Danach setzen Sie ParseName ein und bekommen so das FolderItem-Objekt der Datei. In diesem Kapitel finden Sie unzählige Beispiele für diesen Mechanismus, denn er ist Ihr Tor zum Shell-Dateisystem.
6.4.13 Self Property Self As FolderItem
Diese sehr wichtige Eigenschaft ist erst bei Windows 2000 verfügbar. Das Folder-Objekt selbst liefert an keiner Stelle seinen echten Pfadnamen zurück. Wenn Sie sich also mit BrowseForFolder einen Ordner aussuchen, dann bekommen Sie zwar ein Folder-Objekt, wissen aber nur dessen Titel – nicht dessen Pfadnamen. Nur FolderItem-Objekte verraten über Path den echten Pfadnamen. Mit Self erhalten Sie automatisch das FolderItem-Objekt, das Ihren Ordner im übergeordneten Ordner repräsentiert. So leicht finden Sie bei Windows 2000 den echten Ordnernamen heraus, wenn Sie ein Folder-Objekt besitzen: MsgBox folder.self.path
6.4.14 Synchronize Sub Synchronize
Dieser Befehl synchronisiert einen Offline-Ordner mit dem Server und ist nur bei Windows 2000 vorhanden. Was genau Offline-Ordner sind, wurde bereits bei OfflineStatus beschrieben. Die folgenden Zeilen genügen, um einen nichtaktuellen Offline-Folder mit dem Original zu synchronisieren: if folder.offlineStatus = 3 then folder.Synchronize end if
6.5
Den Explorer fernsteuern: IWebBrowser2
171
6.4.15 Title Property Title As String
Liefert den Titel eines Ordners zurück. Dieser Titel entspricht nicht dem Pfadnamen des Ordners, wie das nächste Beispiel zeigt: ’ 6-30.vbs set shell = CreateObject("Shell.Application") set folder = shell.NameSpace("C:\") MsgBox folder.Title ' nur bei Win2000 möglich: MsgBox folder.self.path
6.5
Den Explorer fernsteuern: IWebBrowser2
Vielleicht haben Sie sich insgeheim schon gefragt, wie Windows eigentlich Ordner im Explorer sichtbar macht. Der Rahmen ist klar: Ein Explorerfenster bildet die Theaterbühne. Nur: Wie kommen die Ordner in den Explorer hinein? Wer glaubt, der Explorer sei selbst für die Darstellung von Ordnern und Dateien zuständig, der täuscht sich: Der Explorer ist ein Allzweck-Datensichtgerät. Er selbst ist eigentlich nur ein armes Würstchen und kann überhaupt keine Daten selbst anzeigen. Statt dessen bedient er sich Plug-Ins. Die stellen dann maßgeschneidert HTML-Seiten, virtuelle Ordner wie die Systemsteuerung oder eben die echten Dateisystem-Ordner dar. Das Plug-In ist seinerseits wieder nur ein Objekt und hört auf den Namen IWebBrowser2. Und wie kommt man an dieses Objekt heran? Starten Sie einen Explorer auf herkömmliche Weise, zum Beispiel über das Arbeitsplatz-Symbol auf dem Desktop, dann hat Ihr Script keine Möglichkeit, an die internen Objekte heranzukommen. Es fehlt der Hintereingang. Anders ist das, wenn Sie selbst scriptgesteuert einen Explorer auf die Bildfläche zaubern. Dann nämlich haben Sie Zugang zum Explorer und all seinen Objekten. So einfach bekommen Sie einen Explorer, der das Laufwerk C:\ anzeigt und dabei komplett per Script gesteuert werden kann: ’ 6-31.vbs set ie = CreateObject("InternetExplorer.Application") ie.visible = true ie.navigate "C:\" MsgBox TypeName(ie)
172
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
6.5.1
Kosmetik: Die Display-Eigenschaften des Explorers steuern
Schauen Sie sich zuerst an, wie Sie Ihr Explorerfenster besser aussehen lassen: Funktion
Bedeutung
AddressBar MenuBar Resizable StatusBar ToolBar Visible Quit Width Height Left Top
False: Adreßleiste wird ausgeblendet False: Menüleiste wird ausgeblendet False: Fenstergröße kann nicht geändert werden False: Statusleiste wird ausgeblendet False: alle Symbolleisten werden ausgeblendet False: Explorerfenster ist unsichtbar (Voreinstellung) Explorerfenster wird geschlossen Breite des Fensters in Pixeln Höhe des Fensters in Pixeln Abstand vom linken Bildschirmrand in Pixeln Abstand vom oberen Bildschirmrand in Pixeln
Tab. 6.10: Eigenschaften des Internet Explorers
So einfach bekommen Sie ein leeres Explorer-Fenster, in dem alle Symbolleisten abgeschaltet sind. Das Fenster ist 500x200 Pixel groß. ’ 6-32.vbs set ie = CreateObject("InternetExplorer.Application") ie.ToolBar = false ie.StatusBar = false ie.Width = 500 ie.Height = 200 ie.visible = true
Mit Hilfe von Left und Top könnten Sie das Fenster in Bildmitte zentrieren, aber dafür müßten Sie die augenblickliche Bildschirmauflösung wissen. Diese Information fehlt momentan noch. Sie lernen aber unten Wege kennen, auch die aktuelle Bildschirmauflösung herauszufinden.
Bild 6.18: Ein leeres Fenster mit Wunschmaßen – noch ist es allerdings leer
6.5
6.5.2
Den Explorer fernsteuern: IWebBrowser2
173
Navigieren: Inhalt im Explorer anzeigen
Ein leeres Explorerfenster nützt Ihnen natürlich herzlich wenig. Deshalb beauftragen Sie den Explorer, an einen Ort zu navigieren. Das folgende Script zeigt, wie Sie den Explorer anweisen, Inhalte anzuzeigen: ’ 6-33.vbs ’ ordner anzeigen set explorer1 = ExplorerShow("C:\") MsgBox TypeName(explorer1.document) ’ virtuellen Ordner anzeigen arbeitsplatz = "::{20D04FE0-3AEA-1069-A2D8-08002B30309D}" systemsteuerung = "::{21EC2020-3AEA-1069-A2DD-08002B30309D}" set explorer2 = ExplorerShow(arbeitsplatz & "\" _ & systemsteuerung) MsgBox TypeName(explorer2.document) ’ dynamisches HTML anzeigen set explorer3 = ExplorerShow("JavaScript:’Guten Tag, es ist " _ & time & "’") MsgBox TypeName(explorer3.document) ’ Textdatei anzeigen set explorer4 = ExplorerShow("C:\msdos.sys") MsgBox TypeName(explorer4.document) ' ' ' '
ebenfalls möglich: ftp-Adressen Webseiten HTML-Dateien
function ExplorerShow(was) set ie = CreateObject("InternetExplorer.Application") ie.ToolBar = false ie.StatusBar = false ie.width = 500 ie.height = 200 ' zum Ziel navigieren ie.navigate was ' warten, bis Ziel vollständig angezeigt wird do until ie.ReadyState=4 loop ' sichtbar machen ie.visible = true ' Referenz auf Explorer zurückgeben set ExplorerShow = ie end function
174
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
Erstaunlich, oder? Der Explorer kann normale Ordner, virtuelle Ordner, dynamisches HTML und sogar einfache Textdateien anzeigen! Das Prinzip ist ganz simpel: Mit navigate beauftragen Sie den Explorer, etwas anzuzeigen. Natürlich kann es einen Moment dauern, bis der Explorer am Ziel angelangt ist und auch tatsächlich den gewünschten Inhalt anzeigt. Deshalb prüft das Script in einer Schleife, ob ReadyState den Wert 4 meldet. Der bedeutet: Alles klar, der Explorer ist mit dem Bildaufbau fertig. Erst danach schaltet das Script das Explorerfenster auf sichtbar. Dies hat nicht nur kosmetische Gründe. Das Script möchte herausfinden, welches Plug-In jeweils die Informationen im Explorer anzeigt. Diese Information liefert document, aber erst, wenn das Plug-In auch tatsächlich initialisiert ist. Dies ist der eigentliche Grund, warum das Script in der ReadyState-Schleife wartet, bis der Explorer-Bildaufbau abgeschlossen ist. Und tatsächlich enthüllt das Script: Es kommen zwei ganz unterschiedliche Plug-Ins zum Einsatz! Ordner und virtuelle Ordner werden mit IShellFolderViewDual angezeigt, HTML und Texte dagegen über HTML Document.
6.5.3
Per Script in den Explorer-Inhalt eingreifen
Nach wie vor bleibt die Frage, wo denn nun eigentlich das Folder-Objekt im Explorer haust, wenn der Explorer Ordner anzeigt. Das Folder-Objekt erreichen Sie über die Folder-Eigenschaft des IShellFolderViewDual-Objekts. Klingt ziemlich verschachtelt, ist aber ganz einfach: ’ 6-34.vbs ’ ordner anzeigen set explorer1 = ExplorerShow("C:\") ’ hier ist das Folder-Objekt! set folder = explorer1.document.folder ’ damit kann ganz normal hantiert werden: for each folderitem in folder.items list = list & folderitem.name & vbCr next MsgBox list explorer1.quit function ExplorerShow(was) set ie = CreateObject("InternetExplorer.Application") ie.ToolBar = false ie.StatusBar = false ie.width = 500 ie.height = 200 ’ zum Ziel navigieren ie.navigate was ' warten, bis Ziel vollständig angezeigt wird
6.5
Den Explorer fernsteuern: IWebBrowser2
175
do until ie.ReadyState=4 loop ’ sichtbar machen ie.visible = true ' Referenz auf Explorer zurückgeben set ExplorerShow = ie end function
Allerdings ist der reine Zugriff auf das Folder-Objekt nicht sonderlich spannend. Schließlich haben Sie eben reichlichen Aufwand betrieben, den Explorer mit seinem Folder-Objekt sichtbar zu machen. Das macht nur Sinn, wenn es auch Möglichkeiten gibt, in den sichtbaren Explorer einzugreifen. Und genau diese Möglichkeiten gibt es auch. Schauen Sie sich an, was das IShellFolderViewDual-Objekt zu bieten hat: Funktion
Beschreibung
PopupItemMenu SelectedItems FocusedItem SelectItem Folder ViewOptions
Öffnet Kontextmenü eines FolderItem-Objekts Liefert eine FolderItems-Liste mit den derzeit markierten Objekten zurück Liefert das FolderItem-Objekt des ausgewählten Eintrags Markiert ein FolderItem-Objekt im Explorer Liefert das Folder-Objekt zurück, das im Explorer angezeigt wird Liefert die derzeitige Ansicht des Explorer-Fensters zurück
Tab. 6.11: IShellFolderViewDual – das Herz des Datei-Explorers
6.5.4
Dateien im Explorer ferngesteuert markieren
Die wohl interessanteste Funktion ist SelectItem. Sie markiert einen oder mehrere Einträge im Explorer. Ihr Script könnte also – basierend auf den Informationen, die Sie oben kennengelernt haben – eine Vorauswahl treffen und diese Dateien dann im Explorer markieren. Das nächste Script zeigt, wie so etwas geht. Es markiert eine beliebige Datei oder einen Ordner im Explorer. ’ 6-35.vbs ShowMe "C:\msdos.sys" sub ShowMe(path) ordner = left(path, InstrRev(path, "\")) datei = mid(path, InstrRev(path, "\")+1) set explorer = ExplorerShow(ordner) set folder = explorer.document.folder set folderitem = folder.ParseName(datei) ’ datei markieren on error resume next explorer.document.SelectItem folderitem, 1+4+8+16
176
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
if not err.number=0 then MsgBox "Datei """ & datei & """ konnte nicht angezeigt werden!" end if on error goto 0 end sub function ExplorerShow(was) set ie = CreateObject("InternetExplorer.Application") ie.ToolBar = false ie.StatusBar = false ie.width = 500 ie.height = 200 ’ zum Ziel navigieren ie.navigate was ' warten, bis Ziel vollständig angezeigt wird do until ie.ReadyState=4 loop ' sichtbar machen ie.visible = true ' Referenz auf Explorer zurückgeben set ExplorerShow = ie end function
Denken Sie bitte daran: Das Script kann nur funktionieren, wenn die gewünschte Datei auch tatsächlich im Explorer zu sehen ist. Haben Sie zum Beispiel Ihrem Explorer befohlen, versteckte – und Systemdateien auszublenden, dann kann das Script die Datei MSDOS.SYS natürlich nicht markieren. Gleiches gilt, wenn Sie Ordner oder Dateinamen angeben, die nicht existieren.
Bild 6.19: Automatisch Dateien in Ordnern markieren
Dies sind die Optionen, mit denen Sie SelectItem steuern: Option
Bedeutung
0 1 1+2
Markierung entfernen Markieren Umbenennen
6.5
Den Explorer fernsteuern: IWebBrowser2
Option
Bedeutung
4 8 16
Alle Markierungen entfernen mit Ausnahme dieser Markierung Markierten Eintrag ins Blickfeld rücken Markiertem Eintrag den Fokus geben (Eintrag wird von dünner Linie umrahmt)
177
Tab. 6.12: Markierungsoptionen im Explorerfenster
6.5.5
Eigenschaften-Dialogfenster aufrufen
Erinnern Sie sich? Mit InvokeVerb hatten Sie oben in Kapitel 6.3.4 bereits Eigenschaften-Fenster aufgerufen. Die hatten aber einen Nachteil: Sie waren nur so lange sichtbar, wie Ihr Script lief. Mit Ihrem neugewonnenen Wissen geht es besser. Navigieren Sie einfach mit dem Explorer zu der gewünschten Datei, und rufen Sie dann im Folder-Objekt des Explorers den InvokeVerb-Befehl auf. Damit bürdet Ihr Script die weitere Verwaltung dem Explorer auf, und selbst wenn Sie die Instanz des Explorers säuberlich mit Quit beenden, bleibt das Eigenschaften-Fenster sichtbar. Der Grund: Die Mutterinstanz aller Explorer-Fenster läuft noch immer, sie ist ständig vorhanden. ’ 6-36.vbs ShowProps "C:\msdos.sys" sub ShowProps(path) ordner = left(path, InstrRev(path, "\")) datei = mid(path, InstrRev(path, "\")+1) set ie = CreateObject("InternetExplorer.Application") ie.navigate ordner ' warten, bis Ziel vollständig angezeigt wird do until ie.ReadyState=4 loop set folder = ie.document.folder set folderitem = folder.ParseName(datei) folderitem.InvokeVerb "E&igenschaften" ie.Quit end sub
Mit dem vorherigen Script können Sie die Eigenschaften von Ordnern und Dateien aufklappen, aber nicht die von Laufwerken. Schade eigentlich, genau das wäre interessant. Ein Script könnte zum Beispiel den freien Speicherplatz ermitteln und bei Speichernotstand die Eigenschaften-Seite des Laufwerks zücken. Funktioniert auch. Erinnern Sie sich? Alle Laufwerke sind ihrerseits Elemente im Arbeitsplatz-Fenster, und das Arbeitsplatz-Fenster kann über seine GUID angesteuert werden. Verwenden Sie also als Ordner die GUID des Arbeitsplatzes und als »Datei« den Namen des Laufwerks, dann zaubert das Script doch noch die gewünschte Information herbei:
178
Kapitel 6: Zugriff auf die Webansicht: Shell.Application
’ 6-37.vbs ShowDriveProps "C:\" sub ShowDriveProps(path) ordner = "::{20D04FE0-3AEA-1069-A2D8-08002B30309D}" datei = path set ie = CreateObject("InternetExplorer.Application") ie.navigate ordner ' warten, bis Ziel vollständig angezeigt wird do until ie.ReadyState=4 loop set folder = ie.document.folder set folderitem = folder.ParseName(datei) folderitem.InvokeVerb "E&igenschaften" ie.Quit end sub
6.5.6
In HTML-Dokumente eingreifen
Auch ganz normale HTML-Dokumente, die im Explorer angezeigt werden, können scriptgesteuert verwaltet werden. Das ist zwar nicht das Thema dieses Kapitels, funktioniert aber nach genau denselben Prinzipien. ’ 6-38.VBS htmlstart = "JavaScript:’
Huhu!" _ & "initialisiere...’" set explorer = ExplorerShow(htmlstart) for x=1 to 1000 explorer.document.body.innerHTML = "Zählerstand: " & x next explorer.Quit function ExplorerShow(was) set ie = CreateObject("InternetExplorer.Application") ie.ToolBar = false ie.StatusBar = false ie.width = 500 ie.height = 200 ' zum Ziel navigieren ie.navigate was ' warten, bis Ziel vollständig angezeigt wird do until ie.ReadyState=4 loop
6.5
Den Explorer fernsteuern: IWebBrowser2
179
’ sichtbar machen ie.visible = true ’ Referenz auf Explorer zurückgeben set ExplorerShow = ie end function
Sie brauchen dem Explorer noch nicht einmal eine »echte« HTML-Datei anbieten. Über das Schlüsselwort JavaScript:’...’ akzeptiert der Explorer auch synthetische HTML-Tags. Der Text, den Sie im <TITLE>-Tag festlegen, wird in der Titelleiste des Fensters angezeigt.
Bild 6.20: Dynamische Ausgaben in IE-Fenster schreiben
Über innerHTML läßt sich dann der Inhalt des Explorers jederzeit verändern. Er könnte auf diese Weise als Fortschrittsanzeige dienen. Natürlich ist dies nur die Spitze des Eisbergs. Prinzipiell lassen sich alle DHTML-Möglichkeiten auf diese Weise scriptgesteuert ausnutzen. Tip: Scripts innerhalb von HTML-Seiten Natürlich wird der Web-Profi fragen: Wieso sollte ich umständlich über den WSH ein Explorerfenster öffnen und scriptsteuern, wenn ich doch in jede HTML-Datei mit dem <SCRIPT>-Tag denselben Scriptcode einbetten kann? Die Antwort ist simpel: Scripts, die innerhalb des Explorers als Teil einer Webseite ausgeführt werden, unterliegen viel strengeren Sicherheitsprüfungen, weil solche Scripts aus fremder Hand stammen könnten. Die meisten fortschrittlichen Scripts, die externe Objekte verwenden, laufen deshalb nicht als eingebettete Scripts in Webseiten.
181
7
Eigene Script-Befehlserweiterungen schreiben
Was können Sie tun, wenn Sie per Script ein Problem lösen wollen, für das es keine passende Funktion gibt? Die mitgelieferten COM-Objekte bieten zwar reichhaltige Auswahl, aber dennoch werden immer wieder Probleme entstehen, für die es keine vorformulierten Befehle gibt. Werden Sie kreativ! Schaffen Sie sich Ihre eigenen COM-Objekte! Das ist leichter als Sie denken, und Sie brauchen noch nicht einmal kostspielige Programmierwerkzeuge. Microsoft verschenkt die Visual Basic Control Creation Edition. Auch an Sie! Dieses rund 7 MB große Programmpaket entspricht dem kompletten Visual Basic 5.0 und ist nur um die Funktion beraubt, eigenständige Programme zu entwickeln. Das können Sie leicht verschmerzen, denn Ihre Scripts brauchen lediglich COM-Objekte, um neue Befehle nutzen zu können. COM-Objekte erstellen Sie mit der kostenlosen VB CCE mit links! In diesem Kapitel zeige ich Ihnen, wie Sie sich die VB CCE beschaffen und installieren. Ich zeige Ihnen außerdem, wie leicht es ist, mit diesem Programm und Ihren bisherigen Kenntnissen eigene neue Befehle zu erfinden. Im nächsten Kapitel bombardiere ich Sie dann mit fix und fertigen Lösungen zu allen nur erdenklichen Problemen. Das Ergebnis sind enorm mächtige Befehlserweiterungen, die Sie jederzeit ergänzen, erweitern und an Ihre Kunden weitergeben können.
7.1
Die Visual Basic CCE startklar machen
Wo bekommen Sie die Visual Basic CCE her? Surfen Sie zu msdn.microsoft.com/vbasic/downloads/ cce/. Hier müssen Sie sich zuerst als MSDN-Mitglied registrieren lassen. Das kostet Sie höchstens ein paar Minuten, aber kein Geld. Mit Ihrer persönlichen MSDN-ID können Sie danach die VB CCE herunterladen. Tip: VB CCE – auch auf CD! Auf der Buch-CD finden Sie ebenfalls die VB CCE Installationsdatei, und zwar im Ordner VISUAL BASIC CCE.
Das Ergebnis ist eine ausführbare EXE-Datei. Rufen Sie sie auf, um die VB CCE auf Ihrem System zu installieren. Anschließend finden Sie in Ihrem Programme-Menü die neue Gruppe Visual Basic 5.0 CCE. Darin befindet sich unter anderem das Programm Visual Basic 5.0 CCE. Rufen Sie es auf!
182 7.1.1
Kapitel 7: Eigene Script-Befehlserweiterungen schreiben
Die VB CCE kennenlernen
Die VB CCE öffnet zunächst ein Willkommensfenster und fragt nach, was für eine Sorte von Programm Sie erstellen wollen. Wählen Sie ActiveX Control!
Bild 7.1: Script-Befehlserweiterungen sind ActiveX-Controls
Anschließend sehen Sie Ihre neue Werkbank, die aus einer ganzen Reihe von Einzelfenstern besteht. Ruhig liegt sie da und wartet geduldig darauf, daß Sie mit ihr zu spielen beginnen. Nur: Wo anfangen in all dem Kauderwelsch? Schauen Sie sich zuerst an, was die VB CCE alles für Sie mitgebracht hat:
Toolbox: Ganz links sehen Sie die Toolbox mit all den Steuerelementen, die Sie in selbstgebastelten Fenstern einsetzen können. Die Toolbox läßt sich jederzeit über den gleichnamigen Befehl aus dem View-Menü einblenden, falls Sie sie ausgeknipst haben.
Rechts haben sich gleich drei Fenster angedockt: Project Explorer, Properties Window und Form Layout. Alle drei Fenster können ausgeknipst werden, wenn Sie sie gerade nicht brauchen, und kommen über die entsprechenden Befehle aus dem View-Menü wieder zurück.
In der Mitte sehen Sie das eigentliche Projekt. Es besteht zuerst aus einem grauen Rechteck, dem »nackten« Control. Ein Rechtsklick auf dieses graue Rechteck öffnet ein Kontextmenü, und darin sehen Sie den Befehl View Code. Er schaltet von der grafischen Ansicht um in den Programmiermodus, und nun sehen Sie eine Art Texteditor. Der hilft Ihnen dabei, Ihrem neuen COM-Objekt sinnvolle Befehle beizubringen.
7.1
Die Visual Basic CCE startklar machen
183
Bild 7.2: Gar nicht so kompl