You can script anything!

Page 1 of 16

Visual Basic Script (VBSCRIPT) You can script anything!

Automating the Desktop
Visual Basic Scripting is easy to learn and use! It can be used to automate tasks ranging from Windows Desktop Administration, to Microsoft Office Automation, to controlling and extracting information hosted by a 3270 emulation session for the Mainframe. All you need is an ASCII text file that ends in a .VBS extension and a little creativity.

A few notes on the language itself:

Visual Basic Script Edition is a subset of the Visual Basic language. Comments are declared by a single apostrophe, such as: ' This is a VBSCRIPT comment. Variables can be declared using the DIM, PRIVATE, or PUBLIC keywords. Variables have no explicit data type. All data types are variant by defaul t. The language is not case-sensitive, so Acounter, ACounter and aCounter are considered to be the same variable name regardless of the mix of upper and lower case. Scope is declared using keyword END keyword pairings, such as CLASSEND CLASS, SUBEND SUB, IF END IF. The unit of program development is the SCRIPT file: an ASCII text file containing executable script statements. Statements are continued by leaving a space at the end of the line followed by an underscore. Strings are concatenated using the ampersand symbol as the concatenation operator.

Your toolkit for script development:

Youll need a text editor and a Windows client workstation running Windows 98 or above. For the text editor use any ASCII only text editor like Windows Notepad. The product that allows scripts to execute is Windows Script containing Visual Basic Script Edition. The current version at the time of this writing is version 5.6 and it is available for downloading at http://msdn.microsoft.com/scripting . But, before you download anything try the following procedure to see if you have a current version installed on your desktop machine.

Written by John Papproth

You can script anything!

Page 2 of 16

Checking for Windows Script Support:

Start by opening Notepad and entering the following line: MSGBOX WScript.Version Save the file as Version.VBS Note: If you are using Windows Notepad enclose the filename in quotes to avoid having the .TXT extension appended to the filename. Locate the saved Version.VBS file. You should see an icon that looks like Figure 3. You can run the script by opening the saved file. The .VBS extension should be associated with WSCRIPT.EXE by default. Just double-click the icon. If everything goes well, you should see a pop-up message box like Figure 4. Fig 1 Notepad or any ASCII editor can be used for VBSCRIPT files

Fig 2 Enclose the File name in quotes to retain the .VBS extension

Fig 3 The default icon for VBScript files

Written by John Papproth

You can script anything! Fig 4 Output showing the current Script version

Page 3 of 16

Introduction to Objects:
Object Oriented Programming (OOP) allows you to encapsulate data (fields) and behaviors (properties and methods) using a class. The relationship between a class and an object is similar to the relationship between a blueprint and the home that is built from the blueprint. The class just defines how the object will be built. A full implementation of OOP allows existing classes to be extended by inheritance to create sub-classes. To actually build an object we need to declare a reference of the class and then call the classs constructor. Each object that is created from a class has its own protected set of variables, properties, and methods. In the example above, we referenced an implicit object named Wscript and a property of that object named Version. Note: We did not have to construct an instance (instantiate) of the Wscript object because the script engine had already made this object available to our script. VBSCRIPT has limited (no inheritance) Object Oriented Programming support, which allows you to: create your own classes using the CLASS statement provide constructors (initializers) for your class using the SUB CLASS_INITIALIZE event provide destructors (clean up) for your classes using the SUB CLASS_TERMINATE event hide or expose data or behaviors using the PRIVATE and PUBLIC access modifiers provide methods within the class using the FUNCTION and SUB keywords expose access to hidden variables using the PROPERTY LET and GET statements create (instantiate) objects that reference your own classes using the NEW keyword In addition to creating objects from your own classes, you can also create references to COM objects using the SET statement and the CreateObject method of the Wscript object.

Creating and using an object in VBScript:

First we need to define a class. Well create a class named DemoClass containing a constructor, a destructor, and two public methods: showTime and getTime. The showTime method will not return a value so well use a SUB keyword. The getTime method will return a value with the current time so well use the FUNCTION keyword. We could also have added variables using the PRIVATE access modifier, and PUBLIC properties to retrieve (GET) and update (LET) the variables. Methods, variables, and properties are referred to as members of the class.

Written by John Papproth

You can script anything! Fig 5 A Sample VBSCRIPT Class Definition: DemoClass.vbs
class DemoClass public sub class_initialize msgbox "Construction in progress",vbOkOnly,"class_initialize" end sub public sub class_terminate msgbox "Destruction in progress",vbOkOnly,"class_terminate" end sub public sub showTime() msgbox Now(),vbOkOnly,"showTime" end sub public function getTime() getTime = Now() end function end class

Page 4 of 16

Next we need to declare a reference. This is just a placeholder that we can use to later address the objects members (methods and properties). Fig 6 Declaring an object reference
dim objRef

Finally, lets call the constructor to create the object and tie it to our reference. If this were a COM object we could also have used the CreateObject method instead of the NEW keyword. Note that Visual Basic Script uses the SET keyword to assign a value to an object reference. The class_initialize is invoked each time the class is instantiated into an object. Fig 7 Calling the DemoClass Initializer (Constructor)
set objRef = new DemoClass

Finally we can use the reference to call our objects methods and properties using the dot notation. Each public member of the object is available by following the object reference with a period followed by the member name. Fig 8 Calling an objects public methods
objRef.showTime msgbox objRef.getTime(),vbOkOnly,"Calling getTime"

Ready-made Objects Wscript, WshShell, WshNetwork, and FileSystemObject:

You have seen in our first example that the Wscript object is implicitly available to the script. The following definitions were taken directory from the Microsoft Developer Network (MSDN) and describe other objects that are built into the scripting engine. The WScript object is the root object of the Windows Script Host object model hierarchy. It never needs to be instantiated before invoking its properties and methods, and it is always available from any script file. The WScript object provides access to information such as: command-line arguments, the name of the script file, the host file name, and host version information.

Written by John Papproth

You can script anything!

Page 5 of 16

The WScript object allows you to: create objects, connect to objects, disconnect from objects, sync events, stop a script's execution programmatically, output information to the default output device (either a Windows dialog box or the command console). You create a WshShell object whenever you want to run a program locally, manipulate the contents of the registry, create a shortcut, or access a system folder. The WshShell object provides the Environment collection. This collection allows you to handle environmental variables (such as WINDIR, PATH, or PROMPT). You create a WshNetwork object when you want to connect to network shares and network printers, disconnect from network shares and network printers, map or remove network shares, or access information about a user on the network. The FileSystemObject is used to provide access to a computers file system.

Limited Input and Output to the Windows Desktop Inputbox, Msgbox, and wshShell.PopUp:
For returning input text from the user, VBSCRIPT provides an INPUTBOX function that accepts three string values as input parameters: a prompt, a title for the window caption, and a default value. If the OK button is clicked, the value entered by the user is returned as a string. If the CANCEL button is clicked a zero length string is returned. Fig 9 InputBox Dialog

dim response response=inputbox(msg,title,defaultValue)

Written by John Papproth

You can script anything!

Page 6 of 16

The MSGBOX also accepts three input parameters: a message to be displayed, a button and icon value, and a title for the caption of the dialog window. It displays a dialog box that waits for the user to click a button before returning to the script. Unlike INPUTBOX the response that is returned is not text, but the numeric value corresponding to the button that was clicked. These numeric values are represented by mnemonic constants. Fig 10 MsgBox Dialog

dim response dim msg dim title msg = "Continue?" title = "Confirm" response=msgbox(msg,vbYesNo+vbInformation,title) If response = vbYes then Else ' No was clicked! End if

wshShell.PopUp MSGBOX without the wait!

The wshShell.PopUp method performs in a manner similar to the MSGBOX function. However, the POPUP method does not have to wait for a response by the user. A number of seconds to wait is supplied to the POPUP function as an additional input parameter. If SecondsToWait equals zero (the default), the pop-up message box remains visible until closed by the user. In this case the effect is the same as MSGBOX. However, if SecondsToWait is greater than zero, the pop -up message box closes after SecondsToWait seconds have elapsed with no interaction from the user. Fig 11 Using the Popup Method of the Shell Object

dim btnReturn dim waitSeconds dim buttons dim icon dim wshShell Set wshShell = CreateObject("Wscript.Shell") buttons = vbOkOnly icon = vbInformation waitSeconds = 10 btnReturn = wshShell.Popup(msg, waitSeconds, title, buttons + icon)

Written by John Papproth

You can script anything!

Page 7 of 16

MSGBOX (and wshShell.PopUp) Constants

The Msgbox statement and the PopUp method can share the same VBSCRIPT MSGBOX constants that are used to define the values for the buttons and icon. The following tables were taken directly from the VBSCRIPT Reference page on MSDN. The following constants are used with the MsgBox function to identify what buttons and icons appear on a message box and which button is the default. In addition, the modality of the MsgBox can be specified. Since these constants are built into VBSCRIPT, you don't have to define them before using them. Use them anywhere in your code to represent the values shown for each. Fig 12 VBScript Constants to define MsgBox Button Configurations Constant Value Description vbOKOnly 0 Display OK button only. vbOKCancel 1 Display OK and Cancel buttons. vbAbortRetryIgnore 2 Display Abort, Retry, and Ignore buttons. vbYesNoCancel 3 Display Yes, No, and Cancel buttons. vbYesNo 4 Display Yes and No buttons. vbRetryCancel 5 Display Retry and Cancel buttons. vbCritical 16 Display Critical Message icon. vbQuestion 32 Display Warning Query icon. vbExclamation 48 Display Warning Message icon. vbInformation 64 Display Information Message icon. vbDefaultButton1 0 First button is the default. vbDefaultButton2 256 Second button is the default. vbDefaultButton3 512 Third button is the default. vbDefaultButton4 768 Fourth button is the default. vbApplicationModal 0 Application modal. The user must respond to the message box before continuing work in the current application. vbSystemModal 4096 System modal. On Win16 systems, all applications are suspended until the user responds to the message box. On Win32 systems, this constant provides an application modal message box that always remains on top of any other programs you may have running.

The following constants are used with the MsgBox function to identify which button a user has selected. Fig 13 MsgBox Constant Value vbOK 1 vbCancel 2 vbAbort 3 vbRetry 4 vbIgnore 5 vbYes 6 vbNo 7 Constants returned by the MsgBox Dialog Description OK button was clicked. Cancel button was clicked. Abort button was clicked. Retry button was clicked. Ignore button was clicked. Yes button was clicked. No button was clicked.

Written by John Papproth

You can script anything!

Page 8 of 16

Pieces of a working script:

The following example, DESKTOP.VBS, was developed to demonstrate the basic desktop input and output facilities that are available to the script developer. The script itself also uses encapsulation to demonstrate the Object Oriented capabilities in VBSCRIPT. It is composed of the script mainline and two in-line class definitions. All definitions are contained in a single text file named: Desktop.VBS The function of this script is a bit contrived (but serves as a good demonstration): to prompt for a directory name, change the current directory, and then list the files within that directory. The script mainline declares two variables to hold object references of each class type. Public methods and properties of the objects are called to change and then display the contents of a folder. Fig 14 Referencing the UserInfo and DesktopIO class
Option Explicit ' ' Desktop.VBS ' written by John Papproth ' Demonstrates limited Desktop Input/Output and OOP facilities of VBSCRIPT ' Dim objUserInfo Dim objDesktopIO Set objUserInfo = new UserInfo Set objDesktopIO = new DesktopIO objUserInfo.currentDirectory = _ objDesktopIO.prompt("Enter a directory: ", _ "Change Directory", _ objUserInfo.currentDirectory) Call objUserInfo.showDir() '-------------------------------------------------------------

The DesktopIO class simply provides an encapsulation around the MSGBOX and INPUTBOX functions. While this was definitely not necessary it provides a simple example of the CLASS statement and the use of both a SUB and FUNCTION as methods of the class. In VBSCRIPT, a method created using the SUB keyword cannot return a value, while a method created as a FUNCTION returns a value by setting the name of the FUNCTION equal to the return value before exiting. Fig 15 DesktopIO Class encapsulates MsgBox and InputBox
' ' Class DesktopIO ' Class DesktopIO public sub alert(msg,title) msgbox msg,vbOkOnly+vbInformation,title end sub public function prompt(msg,title,defaultValue) prompt=inputbox(msg,title,defaultValue) end function End Class

The UserInfo class is an example of encapsulating both data and behavior together. All data items are hidden from direct access outside of the class by using the PRIVATE access modifier. The SUBs CLASS_INITIALIZE and CLASS_TERMINATE are used to instantiate and then release the object references that are used by the class. This class also provides examples of: a READ/WRITE property, currentDirectory. a public method, showDir, which is used to display the directory contents. a private method, show, which acts as a wrapper around the wshShell.PopUp method.

Written by John Papproth

You can script anything!

Page 9 of 16

Fig 16 UserInfo Class exposing private fields with public properties

' ' Class UserInfo ' Class UserInfo private private private private private private private private strDomainName strComputerName strUserName strCurrentDirectory wshShell wshNetwork fso io

public sub class_initialize set wshShell = CreateObject("Wscript.Shell") set wshNetwork = CreateObject("Wscript.Network") set fso = CreateObject("Scripting.FileSystemObject") set io = new DesktopIO strDomainName = WshNetwork.UserDomain strComputerName = WshNetwork.ComputerName strUserName = WshNetwork.UserName strCurrentDirectory = WshShell.CurrentDirectory call show("Hello " & strUserName & vbCrLf & _ "Logged in at: " & _ "\\" & strDomainName & "\" & strComputerName & vbCrLf & _ "Current folder: " & _ strCurrentDirectory & _ "","UserInfo") end sub public sub class_terminate call show("Goodbye " & strUserName,"UserInfo") set wshShell = Nothing set wshNetwork = Nothing set fso = Nothing set io = Nothing end sub public property GET currentDirectory() currentDirectory = strCurrentDirectory end property public property LET currentDirectory(value) WshShell.CurrentDirectory = value strCurrentDirectory = WshShell.CurrentDirectory call show("Current folder: " & _ strCurrentDirectory & _ "","UserInfo") end property public sub showDir() dim folder dim file dim fileList set folder = fso.GetFolder(strCurrentDirectory) fileList = "" for each file in folder.Files fileList = fileList & file.name & vbCrLf next call io.alert(fileList,"Dir for " & strCurrentDirectory) end sub private function show(msg,title) dim btnReturn dim waitSeconds dim buttons dim icon buttons = vbOkOnly icon = vbInformation waitSeconds = 10 btnReturn = wshShell.Popup(msg, waitSeconds, title, buttons + icon) show = btnReturn end function End Class

Written by John Papproth

You can script anything!

Page 10 of 16

Creating and Reading ASCII files FileSystemObject and the TextStream Object:
The FileSystemObject is used to provide access to a computers file system. Two of its methods will allow us to create a TextStream object. The TextStream object is used to provide sequential access to a file. You can create a new file or overwrite an existing file by using the FileSystemObject.CreateTextFile method. You can open both a new and existing file by using the FileSystemObject.OpenTextFile method. Fig 17 TextStream Object (created by FileSystemObject methods) Methods: Properties:

Close Method (FileSystemObject object) Read Method ReadAll Method ReadLine Method Skip Method SkipLine Method Write Method WriteBlankLines Method WriteLine Method

AtEndOfLine Property AtEndOfStream Property Column Property Line Property

A Class to read and write text files:

The TextIO class that is defined below encapsulates the relationship between the FileSystemObject and the TextStream object and provides several methods for interacting with text files. The following code demonstrates the use of the TextIO class. We begin by creating a TextIO object reference, and then demonstrate how to create, append, and read from a text file. Fig 18 IOTest Mainline referencing the TextIO Class
Option Explicit ' ' IOTest.vbs ' written by John Papproth ' Demonstrates the text Input/Output facilities of VBScript ' dim i dim io set io = new TextIO ' ' Create ' msgbox "Creating a new file!",vbOkOnly,"IO Test" call io.openOutput("IOTest.txt") for i = 1 to 5 call io.putLine("Line " & i & "..." & Now) next call io.close ' ' Append ' msgbox "Appending to an existing file!",vbOkOnly,"IO Test" call io.openAppend("IOTest.txt") for i = 1 to 5 call io.putLine("Appended Line " & i & "..." & Now) next call io.close ' ' Read ' msgbox "Reading the file!",vbOkOnly,"IO Test" call io.openInput("IOTest.txt") do msgbox io.getLine() loop until io.EOF call io.close

Written by John Papproth

You can script anything!

Page 11 of 16

Fig 19 TextIO.vbs encapsulates TextStream methods in an external class

' ' Class TextIO ' Class TextIO Private ForReading private ForWriting private ForAppending private fso private ts private s ' constants for IO ' constants for IO ' constants for IO ' File System Object ' Text Stream ' Stream line

private sub Class_Initialize ForReading = 1 ForWriting = 2 ForAppending = 8 Set fso = CreateObject("Scripting.FileSystemObject") End sub private sub Class_Terminate end sub public function openInput(s) Set ts = fso.OpenTextFile(s, ForReading, True) end function public function openOutput(s) Set ts = fso.OpenTextFile(s, ForWriting, True) end function public function openAppend(s) Set ts = fso.OpenTextFile(s, ForAppending, True) end function public function getLine() Dim s s = ts.readLine() getLine = s end function public function putLine(s) ts.WriteLIne(s) end function public function close() ts.Close end function public Property GET EOF() EOF = ts.AtendOfStream End property end Class

Advanced Input/Output using HTML and ActiveX:

You can combine the class definitions, script, and HTML to take full advantage of the presentation capabilities that are available in the browser. In the example below we added a script tag to bring in our TextIO class definition as a separate file. We then added a method to read the file using the filename that was selected in the HTML page. Finally we tied the readFile method to the onClick event of the READ button on the HTML page. The result is an ActiveX browser that reads external text files into a table on the HTML page.

Written by John Papproth

You can script anything! Fig 20 ReadFile.html using an HTML page for presentation
<html>

Page 12 of 16

<head><title>Read File</title></head> <script language="vbscript" src="TextIO.vbs"> </script> <script language="vbscript"> option explicit sub readFile() dim io dim s dim f f = InputFile.value set io = new TextIO io.openInput(f) s = "" do s = s & io.getLine() & vbCrlf loop until io.EOF io.close contentName.innerText = f content.innerText = s end sub </script> <body> <font face='Arial' size=4> Click BROWSE to select a file: <input type=file id=InputFile /> <br clear=all /> Click READ/SHOW to view the selected file: <input type=button id=btnRead value='Read/Show' onClick='readFile()' /> <br clear=all /> <table border=1 align=center cellspacing=0 cellpadding=10> <tr> <td> <font face='Arial' size=4> <div id=contentName></div> </font> </td> </tr> <tr> <td> <font face='Courier New'> <div id=content></div> </font> </td> </tr> </table> </font> </body> </html>

Automating Desktop Administration:

MSDN states that Windows Management Instrumentation (WMI) provides access to information about objects in a managed environment. Through WMI and the WMI application programming interface (API), applications can query for and make changes to static information in the Common Information Model (CIM) repository and dynamic information maintained by the various types of providers. Combining script and WMI gives you easy access to the objects within the Windows Operating System. For more information on WMI check out MSDN at: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnanchor/html/anch_wmi.asp As an example, here is a script that reboots the workstation after a 10-second delay.

Written by John Papproth

You can script anything! Fig 21 SystemReboot.vbs Using the WMI API
Option Explicit '-----------------' ' SystemReboot.vbs ' Written by John Papproth ' Reboots after 10 seconds ' '-----------------Dim obj Set obj = new SysCmd Call obj.Reboot

Page 13 of 16

' ' SysCmd Class ' Methods: Logoff,Shutdown,Reboot,Poweroff,Confirm,Notify,Shell ' Class SysCmd '--------------------------------------------------------------' ' private: ' wshNetwork ' wshShell ' ' Private Sub Class_Initialize ' Private Sub Class_Terminate ' Private Sub Win32Shutdown(opt) ' Private Function popup(Prompt,Title,SecondsToWait,Buttons,Icons) ' ' public: ' Public Sub Logoff() ' Public Sub Shutdown() ' Public Sub Reboot() ' Public Sub Poweroff() ' Public Function Confirm(Prompt,Title,SecondsToWait) ' Public Sub Notify(Prompt,Title,SecondsToWait) ' Public Sub Shell(cmdString) ' '--------------------------------------------------------------private wshNetwork private wshShell Private Sub Class_Initialize set wshNetwork = CreateObject("Wscript.Network") Set wshShell = CreateObject("Wscript.Shell") End Sub Private Sub Class_Terminate ' Nothing to do here! End Sub Private Sub Win32Shutdown(opt) if Confirm("Continue?","Shutting down...",10) then dim objWMIService dim strComputer dim colItems dim objOperatingSystem strComputer = "." Set objWMIService = GetObject("winmgmts:" & _ "{impersonationLevel=impersonate,(Shutdown)}!\\" & _ strComputer & _ "\root\cimv2") set colItems = objWMIService.ExecQuery( _ "Select * from Win32_OperatingSystem" _ ) for each objOperatingSystem in colItems objOperatingSystem.Win32Shutdown(opt) next end if End Sub Public Sub Logoff() const LOGOFF = 0 Win32Shutdown(LOGOFF) End Sub Public Sub Shutdown() const SHUTDOWN = 1 Win32Shutdown(SHUTDOWN)

Written by John Papproth

You can script anything!

Page 14 of 16

End Sub Public Sub Reboot() const REBOOT = 2 Win32Shutdown(REBOOT) End Sub Public Sub Poweroff() const POWEROFF = 8 Win32Shutdown(POWEROFF) End Sub Private Function popup(Prompt,Title,SecondsToWait,Buttons,Icons) dim btnReturn btnReturn = wshShell.Popup( _ Prompt, _ SecondsToWait, _ Title, _ Buttons + Icons) popup = btnReturn End Function Public Function Confirm(Prompt,Title,SecondsToWait) if popup(Prompt,Title, SecondsToWait, vbYesNo, vbQuestion) = vbNo then Confirm=false else Confirm=true end if End Function Public Sub Notify(Prompt,Title,SecondsToWait) Call popup(Prompt, Title, SecondsToWait, vbOkOnly, vbInformation) End Sub Public Sub Shell(cmdString) wshShell.run(cmdString) End Sub End Class

Automating a Microsoft Office Application:

Microsoft Office applications can be automated using Visual Basic for Applications (VBA) which runs within the Office product as a macro extension. However, you can also control Microsoft Office by creating a reference to the Application object. Here is a short example to demonstrate how easy it is to start an office application and then interact it with using VBScript. Fig 22 ExcelTest.vbs Scripting Microsoft Office
Option Explicit ' ' ExcelTest.vbs ' written by John Papproth ' dim objExcel dim row dim col Set objExcel = CreateObject("Excel.Application") objExcel.Workbooks.Add row = 1 col = 1 objExcel.ActiveSheet.Cells(row,col) = Now objExcel.Selection.NumberFormat = "mmmm d, yyyy" objExcel.Selection.Font.Name = "Arial" objExcel.Selection.Font.FontStyle = "Regular" objExcel.Selection.Font.Size = 14 objExcel.ActiveWorkbook.SaveAs "ExcelTest.xls" objExcel.Visible = True

Written by John Papproth

You can script anything!

Page 15 of 16

Each office application has a macro recording facility that creates VBA as you are manually performing the steps (such as changing fonts, saving files, etc). See the Tools/Macro menu under your office application to try this. After recording a macro in VBA you can then view the recorded VBA statements and change them into a stand alone VBSCRIPT by qualifying the object references with your script application object name (objExcel in my example above).

Automating Attachmate Mainframe HLLAPI from VBSCRIPT:

Attachmate Extra has a facility for creating macros by recording keystrokes and producing VBA-like output. In a manner similar to automating Microsoft Office, we can also create stand-alone scripts for our host session. Here is an example of a script that connects to an existing Host session, sends a simple command, and then captures and displays the output. Fig 23 Scripting the Mainframe with Attachmate Extra!
Option Explicit ' ' HostTester.vbs ' written by: John Papproth ' ' Purpose: Demonstrates a connection to an Attachmate Extra Session ' ' Call Main Sub Main() Dim Dim Dim Dim Dim Dim Dim Dim Dim Dim System ' Session ' Screen ' milliseconds Rows ' Cols ' Row Buffer Line Lines ' ' ' ' Attachmate System Current Host Session Current Screen ' milliseconds to wait Rows in Current Screen Cols in one Row Row Counter Buffer to hold Screen Image One Line All Lines belimited by vbCrLf ' 1000=1 second

milliseconds = 500

Set System = CreateObject("Extra.System") if System is Nothing Then Msgbox "Could not create the System Object", _ vbOkOnly+vbCritical,"Get Screen" Exit Sub End If Set Session = System.ActiveSession if Session is Nothing Then Msgbox "Could not create the Session Object", _ vbOkOnly+vbCritical,"Get Screen" Exit Sub End If Set Screen = Session.Screen Call Screen.SendKeys("TIME<Enter>") ' Can be any HOST command Call Screen.WaitHostQuiet(milliseconds) Rows = Screen.Rows() Cols = Screen.Cols() Buffer = Screen.GetString(1,1,Rows*Cols) Lines = "" For Row = 1 to Rows Line = Mid(Buffer, ((Row-1)*Cols) + 1, Cols) Lines = Lines & Line & vbCrlf Next Msgbox Lines,vbOkOnly+vbInformation,"Screen" End Sub

Written by John Papproth

You can script anything!

Page 16 of 16

Where to go for more information:

Microsoft provides many code examples on its scripting development center: http://msdn.microsoft.com/scripting Although this article has focused on VBSCRIPT, the Windows Script product also supports Jscript (Microsofts version of Javascript). If you are so inclined, you may also want to experiment with other scripting languages such as ActiveStates Perl (http://www.activestate.com/perl ).

Did I mention?VB.NET, ADO, WINHTTP, and MSSOAP:

The real power of VBScript (or any script interface) is the ability to create and attach to COM objects. Did I mention that you could create your own COM objects using Visual Basic 6.0 or COM Wrappers for VB.NET Components? But before you create your own objects, do a little research on MSDN. There are existing COM objects for database (ADODB), web document (WINHTTP), and web service (MSSOAP) processing!

About the author:

NasPa member John Papproth is a both a MCSD.NET (Microsoft Certified Solution Developer) and SCJP (Sun Certified Java Programmer). He is a consultant for Bass & Associates Inc. a Business Solutions Provider in Omaha NE. John has taught courses in both the Microsoft .NET language suite and the Sun Microsystems Java Language. He can be reached at [email protected].

Resources:
http://msdn.microsoft.com/scripting http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnanchor/html/anch_wmi.asp http://www.activestate.com/perl

Written by John Papproth