Using System Dialog Boxesread.pudn.com/downloads71/ebook/257847/Windows... · 2000. 3. 13. ·...

Chapter 6

Using System Dialog Boxes

In This Chapter� Take advantage of the built-in system dialog boxes to ask for file names,

colors, and fonts

� Get access to the hidden Folder Picker dialog box and use it to ask for folders and files

� Get access to the hidden Icon Picker and display icons stored in any file

� Create your own dialog boxes and display custom lists for selection

� Use the internal ListView element to quickly sort lists

� Learn how to call undocumented API functions

� Convert strings between ANSI and UNICODE

� Write code that runs on all Windows versions

Windows already contains a rich set of system dialog boxes to ask for file names, colors, fonts, and more. To spice up your arsenal of dialog

boxes, all you need is a way to access those dialog boxes.

In addition, Visual Basic contains very versatile dialog box elements. TheListView element, for example, allows you to display lists and sort them in a matter of seconds. The ProgressBar element graphically indicates theprogress. All you need to do is wrap those functions to make them accessibleby script.

In this chapter, you’ll build your own COM objects that provide access to allof these cool features whenever your scripts need them.

Where Do System Dialog Boxes Come From?Did you ever wonder why standard dialog boxes always look almost the same,no matter which software you use? They are provided by Windows to give allsoftware the same look and feel.

4684-8 ch06.f.qc 3/3/00 9:33 AM 85

It’s completely up to you — you can happily accept the offer and use thebuilt-in system dialog boxes, or you can be an individualist and design yourdialog boxes from scratch (as outlined in Chapter 4). It may be a good idea to stick to the system dialog boxes whenever possible, though. Your usersappreciate the professional look, and your scripts also automatically use the most up-to-date dialog boxes. This means that if users run your script on a Windows 2000 machine, they’ll get the new Windows 2000 look and feelwithout a single change in your script code. Even the most sophisticated self-defined dialog boxes start looking dull and ugly after a couple of years, andthey lack important features added to later system dialog boxes.

Microsoft has provided a COM object to easily access the standard dialogboxes. It’s called MSComDlg.CommonDialog. Unfortunately, this object is not part of Windows. Instead, software packages like Microsoft Office orVisual Basic Control Creation Edition bring it along. Just take a look in thescriptobjects.txt file you generated in Chapter 3 to see whether this object is installed on your system. You can also use the following script to find out:

‘ 6-1.VBS

‘ turn off error handling:on error resume next

‘ try to access common dialogs:set comdlg = CreateObject(“MSComDlg.CommonDialog”)

‘ check whether error was raised:if err.number=0 then

MsgBox “Common Dialog COM object available!”else

MsgBox “Common Dialog COM object missing!”end if

MSComDlg.CommonDialog is not absolutely necessary to display the systemdialog boxes. It’s just a wrapper that takes care of all the dirty API handlingusually involved when calling system dialog boxes directly. You can displaysystem dialog boxes without MSComDlg.CommonDialog when you provideyour own wrapper. Below, you’ll find examples for custom wrappers thatprovide access to other system dialog boxes.

Opening system dialog boxesIs the Common Dialog COM object available on your system? Great! Then you can open any system dialog box entirely by script.

Even if MSComDlg.CommonDialog isn’t registered on your system, it might stillbe there. Visual Basic CCE brings it along and redistributes it with all your COMobjects. A little later in this chapter, I’ll show you how to open system dialogboxes using your own COM objects. However, the following scripts do requireMSComDlg.CommonDialog to be registered on your system.

186 Part I: Scripting Kickstart■ ■

4684-8 ch06.f.qc 3/3/00 9:33 AM Page 186

To ask for a filename, use the following script:

‘ 6-2.VBS

whichone = OpenFile(“Choose a File!”, “C:\”, _“Everything|*.*|Text Files|*.TXT|Word-Documents|*.DOC”, 2, 0)MsgBox “Your choice: “ & whichone

function OpenFile(title, dir, filter, index, flags)set comdlg = CreateObject(“MSComDlg.CommonDialog”)if filter = “” then

filter = “All Files|*.*”end if

‘ initialize all dialog properties:comdlg.filter = filtercomdlg.FilterIndex = indexcomdlg.Flags = flagscomdlg.MaxFileSize = 260comdlg.CancelError = falsecomdlg.DialogTitle = titlecomdlg.InitDir = dir

‘ open dialog boxcomdlg.ShowOpen

‘ return selectionOpenFile = comdlg.filename

end function

Windows will pop up its official Open dialog box and allow you to select a file. You’ll see that the Files of type list contains the file types your scriptspecified. This way, your script can easily limit the selection of available filesto any file type you want.

You can even combine file types. If you want the dialog box to show bothWinWord documents and plain text files, use *.doc;*.txt as the selector.

The dialog box may look different on your system. Windows always uses itsstandard dialog boxes, and their appearance varies with the Windows version.

Finding out more information about systemdialog boxes

System dialog boxes support many hidden flags and features. This means it’s a good idea to decode all the hidden information necessary to control the dialog boxes. Just take a look in the scriptobjects.txt file you gener-ated in Chapter 4 and search for MSComDlg.CommonDialog. It reveals wherethe common controls are stored — in this case, comdlg32.ocx. You can now easily generate the hidden “owner’s manual” using script 5-12.VBS (see Figure 6-1). Just supply comdlg32.ocx as the name of the TypeLibrary.

Chapter 6: Using System Dialog Boxes 187■ ■

4684-8 ch06.f.qc 3/3/00 9:33 AM Page 187

You’ll find sample documentation on the CD-ROM, at \info\documentation\comdlg32. Use it if you can’t generate the documentation yourself.

Figure 6-1: Scripts generate full CommonDialog documentation for you.

Using Other System Dialog BoxesThe Open dialog box is just one of many system dialog boxes. To find outabout the others, search for commands that start with Show, as shown inTable 6-1:

Table 6-1 Common Dialog Box Scripting Commands

Command Dialog Box

ShowOpen Open File

ShowSave Save File

ShowFont Select Font

ShowColor Select Color

ShowPrinter Select Printer

ShowHelp Show Help File

Each dialog box has its own set of flags you can use to fine-tune its behavior.The documentation file you just created lists different constant sections andprovides all the documentation.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 188

Managing flags and special behaviorThe section FileOpenConstants, for example, applies to both the Show-Open and ShowSave dialog boxes. To get rid of the Read Only check box, use HideReadOnly alias 4 as a flag. To switch to Multiselect mode, use flagAllowMultiselect alias 512 or &H200. Figure 6-2 lists all available constants.

Figure 6-2: Find out all about the hidden dialog box flags.

You can’t use the constant names in your scripts. Your scripts have no way oflooking inside the TypeLibrary. Instead, use the numeric values. It’s up to youwhether you prefer decimal or hexadecimal (&h...) notation.

Add all the flags’ values you want to use —4 + &h200 opens a multiselectdialog box without the Read Only check box.

Flags work in both ways. You can specify values to fine-tune the dialog box before you display it and read flag values after display to find out about selections the user has made. For example, to find out whether theuser checked the Read Only check box, you can query the flags value. It will only contain interesting information if the user has selected a file. Not all of the flags in the FileOpenConstants section apply to both Open andSave As dialog boxes.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 189

This script opens a multiselect dialog box and returns all the selected files. Italso reports whether or not the user has selected the Read Only check box:

‘ 6-3.VBS

flag = &h200whichone = OpenFile(“Choose a File!”, “C:\”, “Everything|*.*|TextFiles|*.TXT|Word-Documents|*.DOC”, 2, flag)MsgBox “Raw data returned: “ & whichone

‘ Split up multi selection result:‘ space is used as separator:whichone = Split(whichone, “ “)

‘ field index 0 contains path information:path = whichone(0)

‘ list all the files:‘ how many files were selected?filecount = UBound(whichone)

if filecount=0 then‘ just one file selected!MsgBox “You selected one file: “ & whichone(0)

‘ check status of Read Only checkbox‘ is bit 1 set or cleared?‘ works only if just one file was selected!MsgBox “Returned flag: “ & flagif (flag and 1) then

‘ (flag and 1)<>0, transforms to true‘ bit is set!MsgBox “ReadOnly selected!”

elseMsgBox “ReadOnly not selected!”

end if

‘ check whether selected file is of default type (txt) if (flag and 1024) then

MsgBox “selected file is no txt file!”else

MsgBox “selected file is of default type!”end if

else‘ more than one file selected!MsgBox “You selected “ & filecount & “ files!”

for x = 1 to UBound(whichone)list = list & path & whichone(x) & vbCr

next

MsgBox listend if


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 190

function OpenFile(title, dir, filter, index, flags)set comdlg = CreateObject(“MSComDlg.CommonDialog”)comdlg.filter = filtercomdlg.FilterIndex = indexcomdlg.Flags = flagscomdlg.MaxFileSize = 260comdlg.CancelError = falsecomdlg.DialogTitle = titlecomdlg.InitDir = dir

‘ set txt as defaultcomdlg.DefaultExt = “txt”

comdlg.ShowOpenOpenFile = comdlg.filename

‘ important: return flag status so your main script can‘ check it:flags = comdlg.Flags

end function

This script demonstrates many things at once. Most important, it uses thereturned flag value to check whether certain conditions are met. For example,the script checks whether or not the user has selected the ReadOnly checkbox. This check box is handled by value 1 (ReadOnly). However, you can’t goahead and check whether flag equals 1. After all, flag contains a sum of manypossible values. Therefore, you need to check the bits.

Checking bits is much easier than it sounds. To find out whether 1 is set in flag,check (flag and 1). If 1 isn’t set (and the ReadOnly checkbox wasn’t selected),the result is 0.

0 always equals false, and any other number always equals true, so you can write:

if (flag and 1) thenMsgBox “1 is set, ReadOnly is checked!”

end if

Both the ReadOnly and the ExtensionDifferent flags are only used whenexactly one file is selected. If more than one file is selected, the flags are useless.

In addition, the script demonstrates how to react to multiple file selections.Flag AllowMultiselect (512/&h200) allows you to select more than one file.Windows now uses a special version of the dialog box.

In Multiselect mode, spaces are used as separators between file names.Because long filenames can contain spaces, too, the dialog box converts anyfile name with spaces to short (DOS) file names. Windows 2000 works verydifferently — filenames are enclosed in quotes, and the multiselect Opendialog box looks just like the regular Open dialog box. You need to changeyour script code to correctly interpret the Windows 2000 results returned in multiselect mode.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 191

Picking a colorThe Color dialog box uses a completely different set of flags. They arespecified in the ColorConstants section. The flags now control whether the detailed color picker is visible and whether you can specify an initialcolor (see Figure 6-3).

Figure 6-3: Take advantage of special color flags to adjust the Color dialog box.

The easiest way to provide a color is by using hexadecimal notation. Just use&h. This way, you can easily specify the color values for red, green, and blueseparately. Use 00 to FF for each color component, and add the values in thefollowing order: red, green, and blue. To use CC as red and 8C as green and 35 as blue, write &hCC8C35. The higher the values, the brighter the color.

This is all you need to pick a color:

‘ 6-4.VBS

flag = 1+2initialColor = &hff32eacolor = OpenColor(initialColor, flag)MsgBox “Selected color: “ & hex(color)

function OpenColor(initColor, flags)set comdlg = CreateObject(“MSComDlg.CommonDialog”)comdlg.Color = initColorcomdlg.Flags = flagscomdlg.ShowColorOpenColor = comdlg.Color

end function

Flag 1 allows you to predefine the color, and flag 2 instructs the dialog box toopen the detail color picker (see Figure 6-4).


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 192

Figure 6-4: Control the color picker from your scripts.

If you don’t specify an initial color, the brightness slider on the right side is setto dark black by default. Because all colors are now black, it appears as if youcouldn’t select a color. In truth, you just need to increase the brightness. It’s alot more elegant to set an initial brightness of above 0. To change brightness,use gray values as initial color. Gray values always use the same numbers forred, green, and blue. So, choose &h888888 or &hCCCCCC or &h3D3D3D as theinitial color.

Wrapping System Dialog BoxesThere are a number of good reasons why you should wrap system dialogboxes in self-defined COM objects instead of using MSComDlg.CommonDialogdirectly. For one, wrapping dialog boxes will make them work even on systemswhere MSComDlg.CommonDialog is not yet installed. Second, you now candefine optional parameters. This way, you can call your dialog boxes withdefaults or specify as many details as you want. Wrapping dialog boxes makes them much easier to use and more dependable, too.

Wrapping system dialog boxes has two more advantages. First, your scriptisn’t cluttered with dialog box-related code. It looks a lot cleaner. Second, youdon’t need to worry anymore about variables you used inside your dialog boxprocedures. Recall from Chapter 3 the discussion about private and publicvariables and how they can interfere with each other.

Creating your own system dialog boxesTo wrap system dialog boxes, just start the Visual Basic CCE (refer to Chapter 4 if this sounds unfamiliar to you).

You’ll find the entire project on the companion CD. Just open \components\comdlg\comdlg.vbp. Too lazy to create the COM object yourself? Kick backand call \install\comdlg\setup.exe.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 193

Create a new ActiveX Project. Next, you need to insert a reference to thecommon dialog boxes before you can start using them. Open the View menuand choose Toolbar to open the toolbar window. Right-click the toolbar, andchoose Components (see Figure 6-5).

Figure 6-5: Include additional control elements in your VB CCE toolbox.

You now see a list of optional components. Look for Microsoft Common DialogControl and click the check box. Then click OK.

Is Microsoft Common Dialog Control missing in your list? Click Browse andsearch for comdlg32.ocx manually.

The CCE inserts a new control into the toolbox window: the commoncontrols. Double-click the new icon to place a copy on your UserControl(see Figure 6-6).

Now it’s time to assign a name to your project and your UserControl. Youmight call them dlg.tools. (For tips on how to name your project, refer toChapter 4.)

Getting access to the system dialog boxesYou’re all set. Just start to develop the functions you want to make availablethrough your COM object. You don’t need CreateObject anymore. Thecommon controls are already placed on your UserControl, and you canaccess them by name. It’s CommonControls1 by default.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 194

Figure 6-6: Place a copy of the CommonControl wrapper on your user control.

Actually, your wrapper uses the same COM object that MSComDlg.CommonDialog used, too. However, because its functions are now integrated into your COM object by “early binding” (this is what you did when you inserted the component into your toolbar window), there need not be any MSComDlg.CommonDialog Registry entries anymore. You still need comdlg32.dll, though. If you plan to distribute your dialog boxwrapper control, make sure you also distribute comdlg. The best way is to use the Application Wizard as outlined in Chapter 4.

First, let’s develop an easy function wrapper for ShowOpen:

Option Explicit

Function ShowOpen(Optional ByVal initdir As String, _Optional ByVal title As String, Optional flags As Variant, _Optional ByVal filter As String = “all files|*.*”, _Optional ByVal index As Long = 1) As String

If Not IsMissing(flags) ThenCommonDialog1.flags = flags

End If

If Not IsMissing(initdir) ThenCommonDialog1.initdir = initdir

End If

If Not IsMissing(title) ThenCommonDialog1.DialogTitle = title

End If

CommonDialog1.filter = filterCommonDialog1.FilterIndex = index

CommonDialog1.ShowOpenShowOpen = CommonDialog1.filename


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 195

If Not IsMissing(flags) Thenflags = CommonDialog1.flags

End IfEnd Function

Your COM object makes heavy use of optional arguments. A little later in the chapter, you’ll see how much easier they make your life. Note thatsome optional arguments have default values; others do not. Always useisMissing when dealing with arguments without default value. Also notehow the function returns flag values. Changed flag values will only bereturned if the user has supplied a flag variable in the first place. To be able to return the changed flags through the flag arguments, they need to be declared as ByRef. This way, script and COM object both share the same variable.

Whenever you use ByRef, use Variant as variable type. If you don’t, you will need to convert variable types before you can call your COM functions.Remember, VBScript always uses variants if not told otherwise. To use anargument ByRef, either specify ByRef instead of ByVal, or don’t specifyeither one. ByRef is the default.

Compile your project: Open the File menu and choose Make dlg.ocx(see Figure 6-7). Next, enjoy your new command:

‘ 6-5.VBS

set dlg = CreateObject(“dlg.tools”)MsgBox dlg.ShowOpen

Figure 6-7: Design your dialog box wrapper and then compile, using Make.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 196

Just for the fun of it, compare this script to the previous ones. How muchcleaner and more straightforward things are now. And thanks to the optionalarguments, you are still able to do all the tweaking you discovered above:

‘ 6-6.VBS

set dlg = CreateObject(“dlg.tools”)

flag = 0whichone = dlg.ShowOpen(“C:\”, “Choose a File!”, _flag, “Everything|*.*|Text Files|*.TXT|Word-Documents|*.DOC”, 2)

MsgBox “Selected file: “ & whichoneMsgBox “Returned flags: “ & flag

Using the Folder PickerDid you notice that none of the system dialog boxes managed by the commoncontrols allows you to select a folder? This is bad, but fortunately Microsofthas added another dialog box just for this purpose. It’s part of Windows 98and Windows 2000.

On older Windows versions, just install Internet Explorer 4 . It brings alongthe Shell.Application COM object. This object contains the Folder Picker.However, for some strange reason, Internet Explorer 5 doesn’t bring along the Shell.Application-Object.

Check out the new dialog box:

‘ 6-7.VBS

set shell = CreateObject(“Shell.Application”)set result = shell.BrowseForFolder(0, “Select a folder!”, 0, “C:\”)MsgBox TypeName(result)MsgBox “You selected: “ & result.Title

The script calls the hidden BrowseForFolder method to open the dialog box(see Figure 6-8). In return, it receives an object reference to a Folder2 object(it’s called Folder on older Windows versions). You can retrieve the name ofthe selected folder using the Title property.

This all looks a bit strange. Even worse, there is no way to retrieve the fullpath name. So, this dialog box seems pretty useless.

The more common system dialog boxes are managed by a COM object calledcomdlg32.ocx, or the common dialogs. This object wraps a lot of theinternal techniques necessary to handle the dialog boxes.Shell.Application offers a wrapper for the Folder Picker dialog:BrowseForFolder. However, this wrapper was never intended for public use.It’s targeted towards the internal Web view requirements of the Windowsshell, and it’s not suited for general path inquiries. Therefore, you need towrite your own Folder Picker wrapper and access the dialog box directlyusing very basic API functions.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 197

Figure 6-8: BrowseForFolder is a special dialog box wrapper used by the shell.

Accessing Folder Picker through API functions

To fully exploit all the fascinating functions hidden in the Folder Picker, youjust need to wrap it as a COM object. So, start your VB CCE and create a newActiveX Project (refer to Chapter 4 if this sounds unfamiliar to you).

As always, you can find the complete project on CD by looking at\components\folderpicker\pickfolder.vbp. If you are not interested in the internal mechanics and just want to use the Folder Picker, install theprepared software package —\install\folderpicker\setup.exe. This is the “wrapper” code:

Option Explicit

‘ define a custom structurePrivate Type BrowseInfo

hwndOwner As LongpIDLRoot As LongpszDisplayName As LonglpszTitle As LongulFlags As LonglpfnCallback As LonglParam As LongiImage As Long

End Type

‘ declare API functions we need:Private Declare Function GetDesktopWindow Lib “User32” () As LongPrivate Declare Function SHBrowseForFolder Lib “shell32” _(lpbi As BrowseInfo) As LongPrivate Declare Function SHGetPathFromIDList Lib “shell32” _(ByVal pidList As Long, ByVal lpBuffer As String) As Long


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 198

Private Declare Function SHGetSpecialFolderLocation Lib _“shell32” (ByVal hwndOwner As Long, ByVal nFolder As Long, _ListId As Long) As LongPrivate Declare Function SHSimpleIDListFromPath Lib “shell32” _Alias “#162” (ByVal szPath As String) As LongPrivate Declare Sub CoTaskMemFree Lib “ole32.dll” (ByVal hMem As Long)

Public Function BrowseForFolder(ByVal initdir As Variant, _Optional ByVal message As String = “Choose!”, _Optional ByVal flags As Long) As String

Dim rootID As LongDim PIDL As LongDim Path As StringDim nullPos As IntegerDim BInfo As BrowseInfoDim myMessage As String

‘ convert the message string to ANSI code:myMessage = StrConv(message, vbFromUnicode)

‘ check whether user specified a path or a codeIf VarType(initdir) = vbString Then

‘ it’s a path!‘ use undocumented function to create IDList‘ convert path string to Unicode:rootID = SHSimpleIDListFromPath(StrConv(initdir, vbUnicode))

Else‘ it’s a virtual system folder code‘ get “real” pathSHGetSpecialFolderLocation GetDesktopWindow, initdir, rootID

End If

‘ fill out the BrowseInfo structure:BInfo.hwndOwner = GetDesktopWindowBInfo.ulFlags = flags‘ fill in the address of your ANSI message string:BInfo.lpszTitle = StrPtr(myMessage)

‘ is there a valid rootID? Fill it in!If rootID <> 0 Then BInfo.pIDLRoot = rootID

‘ open the dialog box, retrieve a PIDL‘ PIDL is internal identifier for selected folder:PIDL = SHBrowseForFolder(BInfo)

‘ was there a PIDL returned? Transform to path:If PIDL <> 0 Then

‘ reserve space for path namePath = String(260, 0)

‘ return path name from PIDL:SHGetPathFromIDList PIDL, Path

‘ manually release the memory:Call CoTaskMemFree(PIDL)Call CoTaskMemFree(rootID)


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 199

‘ cut off string at char 0:nullPos = InStr(Path, vbNullChar)If nullPos <> 0 Then

Path = Left(Path, nullPos - 1)End If

End If

‘ return path:BrowseForFolder = Path

End Function

Next, assign a name to your project. Call it folder.tools. Now you cancompile it: Open the File menu and choose Make folder.ocx.

I’ll show you in a minute how all of this works. This wrapper employs all the hidden techniques necessary to call internal system functions. Let’s firstconcentrate on the practical aspects, so you can safely steal yourself away to the next chapter anytime you feel like it.

Now, it’s extremely simple to access the Folder Picker. Look for yourself:

‘ 6-8.VBS

set picker = CreateObject(“folder.tools”)result = picker.BrowseForFolder(“C:\”, “Hey, select a folder!”)MsgBox “You selected: “ & result

This time, you receive the full path name (see Figure 6-9).

Figure 6-9: Your own BrowseForFolder wrapper finally returns the correct filename.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 200

There’s a lot more you can do with your new function. Instead of specifying apath name, try using a number. BrowseForFolder can also open any virtualsystem folder, and BrowseForFolder(2) would open your program groups.The next script lets you play around.

Your wrapper only puts a thin layer around the hostile API world. Forexample, the wrapper does not check whether the path you specify reallyexists. Specifying illegal path names may produce strange results — to say the least.

‘ 6-9.VBS

set picker = CreateObject(“folder.tools”)do

showwhat = InputBox(“Enter number or path!”,,2)if not showwhat = vbEmpty then

if isNumeric(showwhat) thenidnr = Fix(showwhat)result = picker.BrowseForFolder(idnr, “ID-Number: “ _

& idnr)answer = MsgBox(result & vbCr & “Again?”, vbYesNo)

elseresult = picker.BrowseForFolder(showwhat, _

“Showing Path”)answer = MsgBox(result & vbCr & “Again?”, vbYesNo)

end ifelse

answer = vbNoend if

loop until answer = vbNo

You’ll soon discover that BrowseForFolder can access just about any virtualWindows folder. However, because the dialog box can only display folders, youcan’t see files or individual content.

Not yet. You need two things to fully exploit BrowseForFolder. First, youneed a list of all the codes and available virtual folders. Next, you need a list ofall the special flags BrowseForFolder supports. But where do you get them?

Automatically documenting all secret FolderPicker options

Just ask the appropriate TypeLibrary. The API functions that your wrapperuses doesn’t have a TypeLibrary, but the Shell.Application object uses thesame fundamental API functions, so you can find a lot of the information in theShell.Application TypeLibrary. Take a look into the scriptobjects.txtfile you generated in Chapter 3. You’ll quickly discover that Shell.Applicationstores type information in either shdocvw.dll or shell32.dll.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 201

Not too long ago, Shell.Application and the Web view were just cute add-ons to Windows. Web view wasn’t really integrated into Windows at this stage — instead, it was left to Internet Explorer to handle it. Windows 98featured the integrated Internet Explorer, but it was still up to the integratedInternet Explorer to take care of Web view. Back then, Web view was handledinternally by shdocvw.dll. Beginning with Windows 2000, Microsoft hasincorporated Web view into the core system functionality. For this reason, on Windows 2000, Web view (and its TypeLibrary) is integrated intoshell32.dll. Nobody would dare kick this .dll out of the system. It’s the core of the Windows user interface.

If you haven’t done so already in Chapter 5, launch script 5-12.VBS and let itcreate the documentation for you. On Windows 2000, enter shell32.dll. On all other Windows versions, enter shdocvw.dll.

Next, in your documentation folder, look for ShellSpecialFolderConstants.htm. There you’ll find your list of available virtual folders.

Now you just need the Folder Picker flag values. Unfortunately, Shell.Application doesn’t make use of the special flags, so it doesn’t mentionthem. Here’s a table of them for you.

Table 6-2 Folder Picker Special Flags

Flag Description

1 Accept only file system folders

2 No network folders

8 Accept only file system objects

&h10 Show text field for direct entry

&h1000 Show only computers

&h2000 Show only printers

&h4000 Show files or individual entries

This is all you need to also display individual files or other elements. Thefollowing script displays your Desktop and then your Control Panel content:

‘ 6-10.VBS

set picker = CreateObject(“folder.tools”)result = picker.BrowseForFolder(0, “Desktop”, &h4000)MsgBox “You selected: “ & resultresult = picker.BrowseForFolder(3, “Control Panel”, &h4000)MsgBox “You selected: “ & result


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 202

Everything seems to work fine. Once you select a control panel item, though,your BrowseForFolder function won’t return a value. After some rethinking,this is no surprise — your wrapper function explicitly uses the BrowseFor-Folder dialog box to retrieve file names. Since Control Panel items are notfiles, BrowseForFolder correctly returns an empty value.

Your new BrowseForFolder function is smart enough, though, to translatevirtual objects to their path names if it’s possible. For example, choose theDesktop entry in the first dialog box. Although Desktop is a virtual folder,your BrowseForFolder correctly identifies the folder your desktop contentis stored in.

Getting Access to the Hidden Icon PickerThere’s one more system dialog box, and it’s an important one: The Icon Pickercan display icons stored in files. It’s your only way to present icon selections toyour users. To see the dialog box in action, just follow these steps:

1. Search for any link, then right-click it and choose Properties.

2. Next, click the Change Icon button. There it is: your Icon Picker dialogbox (see Figure 6-10). It may look a little different depending on yourWindows version.

Figure 6-10: Getting to know the hidden Icon Picker dialog box.

How to call undocumented shell functionsWindows desperately tries to keep its Icon Picker dialog box to itself. It’s not documented anywhere, and there’s not even a named API function to call the dialog box. But, with a couple of tricks, you can make it work. Afterall, it must exist or else Windows wouldn’t be able to use it either.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 203

After some research, it turns out that the Icon Picker dialog box is contained inshell32.dll. Its function uses ordinal #62 throughout all the 32-bit Windowsversions, so it’s fairly easy to design an appropriate declare statement to callthe Icon Picker.

However, because this function is undocumented, Microsoft doesn’t take anyeffort to keep things consistent. On Windows 9.x and Windows NT, the IconPicker accepts ANSI strings as arguments. With the advent of Windows 2000,many of the undocumented functions switch to Unicode strings withoutwarning. So, it’s up to your wrapper to determine the Windows version and convert the string arguments appropriately.

I’ve done all of this for you. The source code is a vivid example of developingcross-Windows-version COM objects, and the isWin2000 function can beuseful for other projects, as well. Just install iconpicker.tool from the CDat \install\iconpick\setup.exe. You can also load the complete projectand compile it yourself by using \components\iconpick\iconpick.vbp.

Option Explicit

‘ structure needed to retrieve OS version:Private Type OSVERSIONINFO

size As Longmajorver As Longminorver As Longbuild As Longplatformid As LongCSDVersion As String * 128

End Type

‘ declare undocumented icon dialog function:Private Declare Function IconDialog Lib “shell32.dll” _Alias “#62” (ByVal hwnd As Long, ByVal lpStrFile As Long, _ByVal maxfilelen As Long, IconIndex As Long) As Boolean

Private Declare Function ExtractIconEx Lib “shell32.dll” _Alias “ExtractIconExA” (ByVal lpszFile As String, _ByVal nIconIndex As Long, phIconLarge As Long, _phIconSmall As Long, ByVal nIcons As Long) As LongPrivate Declare Function GetVersionEx Lib “kernel32.dll” _Alias “GetVersionExA” (lpVersionInfo As OSVERSIONINFO) As Long

Public Function PickIcon(ByVal path As String, _Optional ByVal index As Long = 0) As String

Dim ok As BooleanDim filestr As StringDim convert As Boolean

‘ build a string of 260 characters (max path len)‘ that contains the path of the icon library‘ you want to displayfilestr = path & Chr(0) & String(260 - Len(path) - 1, 0)

‘ if not Win2000, string needs to be ANSI:


4684-8 ch06.f.qc 3/3/00 9:33 AM 4

If Not isWin2000 Thenfilestr = StrConv(filestr, vbFromUnicode)

End If

‘ call undocumented dialog box:ok = IconDialog(0&, StrPtr(filestr), 260&, index)

‘ did user select an icon?If ok Then

‘ if not Win2000, ANSI-string needs to be reconverted‘ back to UnicodeIf Not isWin2000 Then

filestr = StrConv(filestr, vbUnicode)End If

‘ resize string - cut off anything beyond terminating‘ chr(0) character:filestr = Left(filestr, InStr(filestr, Chr(0)) - 1)

‘ add index of selected icon:PickIcon = filestr & “,” & index

ElsePickIcon = “”

End IfEnd Function

Public Function CountIcons(ByVal path As String) As Long‘ counts number of icons in given file:

CountIcons = ExtractIconEx(path, -1, 0, 0, 0)End Function

Public Function isWin2000() As Boolean‘ checks whether OS is Win2000:

Dim osinfo As OSVERSIONINFO

osinfo.size = Len(osinfo)GetVersionEx osinfoIf (osinfo.platformid >= 2 And osinfo.majorver >= 5) Then

isWin2000 = TrueElse

isWin2000 = FalseEnd If

End Function

Displaying icons hidden in the system filesThe new Icon Picker is extremely versatile, and you’ll find many usefulexamples in Chapter 23. For now, the following script examines all yoursystem files and displays the icons in the Icon Picker dialog box (see Figure 6-12). Now select an icon. The script tells you the exact syntax of how to access the icon you selected. This syntax becomes important once you assign icons via Registry keys or script commands.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 205

‘ 6-11.VBS

set fs = CreateObject(“Scripting.FileSystemObject”)set icon = CreateObject(“iconpicker.tool”)

‘ get access to system folderset sysfolder = fs.GetSpecialFolder(1)

‘ enumerate all filesfor each file in sysfolder.files

‘ how many icons are stored in file?icons = icon.CountIcons(file.path)

‘ more than 2 files? Show them!if icons>2 then

selection = icon.PickIcon(file.path)‘ did the user select an icon?if selection=”” then

msg = “You did not select an icon.”else

msg = “This is how you access the icon: “ & vbCrmsg = msg & selection

end ifmsg = msg & vbCr & “Continue?”answer = MsgBox(msg, vbQuestion + vbOkCancel)if answer = vbCancel then exit for

end ifnext

MsgBox “Done!”

Figure 6-11: Display icon resources stored in system files.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 206

Displaying and Sorting ListsVBScript is unable to display lists, not to mention sort them. Althoughsorting is an important functionality, you are left alone and need to resort toslow custom VBScript procedures.

Do you really have to live with these limits? No way. A look at the WindowsExplorer proves that there must be some kind of List view and sortingcapability built into Windows. How else would the Explorer be able to displayfolder contents as Details view and allow you to sort those lists in any wayyou please?

The answer is contained in the ListView dialog box component. Thiscomponent can easily display huge lists and sort them by any category youspecify. All you need is a way to access the ListView element.

The ListView element was originally designed to display lists. You don’tneed to, though. It’s up to you — if you prefer, you can use the hide theListView element entirely. In this case, it will only serve to sort lists.

Getting Aacess to the ListViewVBScript has no way of accessing the ListView element directly. You can,however, wrap the ListView element as a COM object. I have done it for you.The full source code is provided on the companion CD. Just open\components\listview\listview.vbp.

Either open the project and compile it yourself, or run\install\listview\setup.ocx. Both ways will register thelistview.tool component.

Designing and sorting listsCheck out how powerful the new ListView element really is. The followingscript reads in all files stored in the root folder of drive C:\. Then, the files aredisplayed in the ListView element. You can sort each column by clicking onthe column heads. Another click sorts in the opposite direction.

You can even find out which file(s) the user has selected. Just select one ormore files in the ListView and then click OK. Your script will report the filedetails.

‘ 6-12.VBS

set fs = CreateObject(“Scripting.FileSystemObject”)set lview = CreateObject(“listview.tool”)

‘ open sample folder:set folder = fs.GetFolder(“C:\”)


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 207

‘ scale dialog boxlview.width = 600lview.height = 400

‘ design some column headers‘ AddHeader name, size in percent, alignment‘ 0 = left (default)‘ 1 = right‘ 2 = center

lview.AddHeader “File name”, 50lview.AddHeader “Size”, 20, 1lview.AddHeader “Type”, 30

‘ read files into ListView:for each file in folder.files

lview.AddItem file.namelview.AddSubitem 1, AlignNumber(file.size)lview.AddSubitem 2, file.type

next

‘ sort result‘ 0 = first column‘ 1 = second column...lview.Sort 0

‘ enable multiselectlview.MultiSelect = true

‘ show ListView Formset result = lview.Show(“Files on Drive C:\”)

list = “Selected items: “ & result.Countfor each entry in result

list = list & entry & vbCrnext

MsgBox list

function AlignNumber(number)size = len(CStr(number))AlignNumber = Space(20-size) & number

end function

The new ListView dialog box allows for both single- and multiselection. Usethe MultiSelect property to determine whether the user will be able toselect more than one file.

The ListView stores String values. To be able to sort numeric content, the script uses the function AlignNumber to pad the numeric strings withspaces. This way, numbers will be sorted correctly. It’s easy to get rid of thepadding spaces: Once a number is returned, just use LTrim to eliminate theleading spaces.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 208

Figure 6-12: Using your own dialog boxes to display lists and select entries.

Your new listview.tool component offers a rich set of options. Use thelabelOK and labelCancel properties to change the labels on the buttons.You can manually sort columns before you display the dialog box by usingSort. With the help of the MultiEdit property, you can even display thesame dialog box more than once and delete entries.

When defining column headers using AddHeader, you can specify up to three arguments: the name of the column header, its size in percent, and the alignment type as documented in the script. The first column always has to be left-aligned, which is also the default.

The next script demonstrates the advanced options. It will delete the selectedentry from the list and continue to display the list until the user hits Cancel.

Whenever you select an entry and either click OK or press [Enter], the scriptdisplays detailed information about this file and removes it from its list. Thenit redisplays the list. The selected items are no longer available.

This is possible because the script enables the MultiEdit property. InMultiEdit mode, the dialog box isn’t destroyed, but hidden, and it canreappear anytime you use Show. In addition, in MultiEdit mode, the dialogbox returns additional information: The internal key name of the selecteditems is appended to the list information and returned. With this key, you can remove list entries using RemoveItem.

‘ 6-13.VBS



4684-8 ch06.f.qc 3/3/00 9:33 AM Page 209

set folder = fs.GetFolder(“C:\”)lview.width = 600lview.height = 400lview.AddHeader “File name”, 50lview.AddHeader “Size”, 20, 1lview.AddHeader “Type”, 30


lview.AddItem file.namelview.AddSubitem 1, AlignNumber(file.size)lview.AddSubitem 2, file.type

next

‘ enable MultiEdit featurelview.MultiEdit = true

‘ show ListView Form until user hits Cancel:do

set result = lview.Show(“Files on Drive C:\”)

‘ did the user select something?if result.Count=0 then

‘ no, exitexit do

end if

‘ split result:details = Split(result.Item(1), vbCrLf)

‘ now the information is contained in an arraymsg = “You selected: “ & details(0) & vbCrmsg = msg & “File Size is “ & ltrim(details(1)) & “ Bytes.” _

& vbCrmsg = msg & “File Type is “ & details(2) & vbCrmsg = msg & “Internal ListView item key is: “ & details(3)

MsgBox msg, vbInformation

lview.removeItem details(3)loop

MsgBox “Done!”

function AlignNumber(number)size = len(CStr(number))AlignNumber = Space(20-size) & number

end function


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 210

Sorting lists without dialog boxesThe great sorting capabilities that the ListView offers can be used separately,too. This way, you can easily sort any kind of list (see Figure 6-13). You don’tneed to display the ListView dialog box.

Whenever you query the files in a folder, Windows returns them in the order they were originally saved. They are not sorted. The following script demonstrates how to build a file list and then have it sorted in the background by your ListView:

‘ 6-14.VBS


‘ open sample folder:set folder = fs.GetFolder(“C:\”)

‘ design some column headerslview.AddHeader “File name”, 50lview.AddHeader “Type”, 30


lview.AddItem file.namelview.AddSubitem 1, file.type

next

‘ Sorting: ‘ sort for type, then for name‘ use reverse order in script:lview.Sort 0 ‘ sort column 0 (name)lview.Sort 1 ‘ sort column 1 (type)

‘ read sorted result without displaying any dialog box:set result = lview.ReadResult

‘ convert collection to strings:list = “”for each entry in result

entry = Split(entry, vbCrLf)list = list & entry(0) & vbTab & entry(1) & vbCr

next

MsgBox list

The sorting capabilities are so powerful you can even sort for multiplecolumns: In the example, the script first sorts column 0 (file name), thencolumn 1 (file type). The result is a sorted list that lists the files sorted by type and within the types sorted by name.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 211

Figure 6-13: Using ListView to sort arbitrary lists.

You need commands to specify the number of list categories and another oneto actually store values in your list.

Diving into documentation and source codeTo get your personal copy of the ListView.tool owner’s manual, launch script5-12.VBS and have it auto-document listview.ocx. Search for listview.ocxfirst to find out its exact path name.

The documentation file is contained on the companion CD:info\documentation\listview\.

The source code is somewhat lengthy, but well-documented. It’s not so muchthe code but rather the ListView object model that makes it a little hard tounderstand. In addition, I was forced to include some API calls. Visual Basic 5(and VBCCE, too) are buggy when it comes to sizing column headers. Forsome unknown reason, VB always adds some extra space to your widthvalues, so it’s almost impossible to size the columns neatly this way.

The source code shows a workaround: It uses the internal SendMessagefunction of Windows to send resizing messages directly to the ListViewelements.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 212

Figure 6-14: Easily auto-document any COM object — even your own!

Successfully Dealing with API FunctionsYou now know how to successfully deal with API functions. It’s a good time toreview some of the basic technologies the previous examples have employed.You don’t have to go through this, but you might find it helpful once you startchanging the example code to suit your own needs.

On the following pages, I’ll show you how to feed text strings to API functionsand get results back safely. I’ll also clarify the ANSI/UNICODE issue, which willhelp with writing code that runs both on Windows 95/98 and on Windows NT/2000.

String handling — undocumented VisualBasic commands

Chapter 4 already revealed the basics about API calls. There’s one more issueto solve, though, and it frequently drives Visual Basic programmers nuts. Youguessed it — it’s string handling.

Many API functions expect strings as arguments. The functions then storesome value into the string so you can retrieve it afterwards.

The Icon Picker, for example, expects the address of a string in which youhave stored the path to the icon library file. In return, the function writes the new icon file into the string if the user changes the file. So, all you need to do is provide a string to the function and read its contents afterwards.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 213

In theory, at least. In everyday life, there are a lot more details to think about.

First of all, many API functions don’t expect a string but rather a reference toa string: its memory address. Therefore, you need to declare this argument asByVal and as Long. It’s an address pointer, not a string.

Next, you need to make sure you reserve enough space for the data thefunction might want to store in your string. So, fill your string with emptydata using String.

Now you are ready to pass the string’s memory address to the API function.But wait a minute! There’s no Visual Basic command that would tell you thisaddress. Right?

But there is. You can always use StrPtr. StrPtr is an undocumented VisualBasic command. It works perfectly well, but it remains hidden because in thewrong hands, this function can cause trouble.

There’s a lot of confusion about address pointers, and many programmersinvest a lot of time and energy using complicated API functions or Byte arraysto copy string values into memory addresses. It’s mostly unnecessary, andvery slow too. Starting with Visual Basic 5, convenient (yet hidden) functionsare built right into VB to handle most of these tasks for you. And because theVB CCE you’re using is based on VB5, you can use these functions as well.

Whenever you deal with pointers yourself, you are no longer protected by the internal Visual Basic safety net. So, you need to make sure you are passingvalid pointers to the places you intend to point to.

Dealing with ANSI and UNICODEAs if things weren’t tricky enough, Microsoft is currently transforming itsinternal string mechanics from ANSI to UNICODE. ANSI strings store onecharacter per byte. That’s enough for some of us, but not enough for all the Chinese characters — let alone all the globally available characters.Therefore, as Microsoft expands worldwide, it migrates its Windows versions to UNICODE. Here, each character is represented by two bytes, allowing for 65,536 different characters.

What does this mean for us? Windows 9.x (and partially Windows NT) usesANSI strings. Windows 2000 is all UNICODE, yet it still contains some ANSIsupport for backwards-compatibility.

The Icon Picker is again a good example. This function expects the file name to be ANSI on Windows 9.x/NT and UNICODE on Windows 2000. Because VisualBasic stores its strings in UNICODE anyway, your code will work perfectly wellon Windows 2000 without any conversion. On all other Windows versions,however, you’ll get strange results. The dialog box won’t be able to find youricon files because it will misinterpret the UNICODE filename where it expectsan ANSI string.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 214

Fortunately, Visual Basic contains the appropriate conversion tools. Just use StrConv. It offers a rich set of conversion schemes and allows for easyUNICODE-ANSI-UNICODE roundtrips. In the Icon Picker example, the codefirst checks whether it’s being run on a non-Windows 2000 system. If so, itconverts the Visual Basic UNICODE strings to ANSI, feeds them to the API-function, and reconverts the result back to UNICODE so Visual Basic canhandle it.

Cutting excess string spaceWhenever you provide string space to an API function, you most likelyreserve more space than you actually need — just in case. Before you can use the resulting strings in Visual Basic, you need to adjust string size, however.

API functions are closely related to C. They determine the size of a string by a terminating null character (vbNullChar). Visual Basic, in contrast, doesn’tcare about nulls. It stores the string length in two bytes right before thestring data starts. So, you definitely need to cut off excess space before you can use the string content in Visual Basic.

This is easy — just have Visual Basic look for the first null character and cutoff the rest:

stringvar = left(stringvar, Instr(stringvar, vbNullChar)-1)

Experimenting and getting source code for free

Always remember: Your Visual Basic Control Creation Edition is a full Visual Basic development environment! I strongly encourage you to searchthe Internet for source code examples. There are many great Web sites outthere with tutorials and samples of various API techniques.

Just launch your VBCCE and choose Open Project from the File menu. Thenload the sample project you downloaded from the Internet and experimentwith it!

Your VBCCE is based on Visual Basic 5.0. Many examples already use Visual Basic 6.0, and you may get error messages when trying to open thoseprojects. However, in most cases, you just need to open the .vbp file in youreditor and remove the attributes that caused the error. A common problem is the line retained =. Completely remove this line, save the .vbp file, andreopen it. This way, you can open and use most Visual Basic 6 projects.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 215

SummaryYou have discovered how to wrap system dialog boxes in COM objects and call them from script. Using the ListView element, you created your own listbox dialog box and found ways to have it sort arbitrary lists quickly and safely.Calling API functions leaves it to you to handle string pointers and stringformats. You now know how to pass string address pointers and how to deal with ANSI/UNICODE conversion to write code that runs equally well on all Windows versions. As a result, you now have a whole armory of newcommands that display virtually any dialog box you may ever need.


4684-8 ch06.f.qc 3/3/00 9:33 AM Page 216

Using System Dialog Boxesread.pudn.com/downloads71/ebook/257847/Windows... · 2000. 3. 13. ·...

Documents

Transcript of Using System Dialog Boxesread.pudn.com/downloads71/ebook/257847/Windows... · 2000. 3. 13. ·...