Visual Basic Articles

Sometimes the data you want to display in a list is too long for the size of ListBox you can use. When this happens, you can use some simple code to display the ListBox entries as ToolTips when the mouse passes over the ListBox.

First, start a new VB project and add a ListBox to the default form. Then declare the SendMessage API call and the constant (LB_ITEMFROMPOINT) needed for the operation:

Option Explicit

'Declare the API function call.
Private Declare Function SendMessage _
Lib "user32" Alias "SendMessageA" _
(ByVal hwnd As Long, _
ByVal wMsg As Long, _
ByVal wParam As Long, _
lParam As Any) As Long
' Add API constant
Private Const LB_ITEMFROMPOINT = &H1A9

Next, add some code to the form load event to fill the ListBox with data:

Private Sub Form_Load()
'
' load some items in the list box
With List1
.AddItem "Michael Clifford Amundsen"
.AddItem "Walter P.K. Smithworthy, III"
.AddItem "Alicia May Sue McPherson-Pennington"
End With
'
End Sub

Finally, in the MouseMove event of the ListBox, put the following code:

Private Sub List1_MouseMove(Button As Integer, Shift As Integer, _
X As Single, Y As Single)
'
' present related tip message
'
Dim lXPoint As Long
Dim lYPoint As Long
Dim lIndex As Long
'
If Button = 0 Then ' if no button was pressed
  lXPoint = CLng(X / Screen.TwipsPerPixelX)
  lYPoint = CLng(Y / Screen.TwipsPerPixelY)
  '
  With List1
    ' get selected item from list
    lIndex = SendMessage(.hwnd, _
    LB_ITEMFROMPOINT, _
    0, _
    ByVal ((lYPoint * 65536) + lXPoint))
    ' show tip or clear last one
    If (lIndex >= 0) And (lIndex <= .ListCount) Then
      .ToolTipText = .List(lIndex)
    Else
      .ToolTipText = ""
    End If
  End With '(List1)
End If '(button=0)
'
End Sub

For example, add a button to a standard VB form and paste the following code into the Click event of the button:

Private Sub Command1_Click()
     '
     ' create a quick array using variants
     '
     Dim aryList As Variant
     '
     aryList = Array("No Access", "Read-Only", "Update", "Delete")
     '
     MsgBox aryList(2)
     '
End Sub

If you need to copy information from database fields into memory variables, you can do it quickly using the GetRows method of the Recordset object. The GetRows method copies one or more rows of data directly into a Variant data type and stores the information as a two-dimensional array in the formvarData(Field,Column).

Most of the Win32 API calls return extended error information when they fail. To get this information in a sensible format, you can use the GetLastError and FormatMessage APIs.

Add the following declarations and function to a BAS module in a VB project:

Option Explicit

Public Declare Function GetLastError _
     Lib "kernel32" () As Long
Public Declare Function FormatMessage _
     Lib "kernel32" Alias "FormatMessageA" _
     (ByVal dwFlags As Long, _
     lpSource As Any, _
     ByVal dwMessageId As Long, _
     ByVal dwLanguageId As Long, _
     ByVal lpBuffer As String, _
     ByVal nSize As Long, _
     Arguments As Long) As Long

Public Const FORMAT_MESSAGE_FROM_SYSTEM = &H1000

Public Function LastSystemError() As String
     '
     ' better system error
     '

     Dim sError As String * 500
     Dim lErrNum As Long
     Dim lErrMsg As Long
     '

     lErrNum = GetLastError
     lErrMsg = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, _
          ByVal 0&, lErrNum, 0, sError, Len(sError), 0)
     LastSystemError = Trim(sError)
     '

End Function

Now place a command button on a standard VB form and call the LastSystemError function:

Private Sub Command1_Click()
     '
     MsgBox LastSystemError
     '

End Sub

If there was no error registered, you'll see a message saying "The operation completed Successfully."

When using this function, keep these points in mind:

1. Many API calls reset the value of GetLastError when successful, so the function must be called immediately after the API call that failed.

2. The last error value is kept on a per-thread basis, therefore the function must be called from the same thread as the API call that failed.

Note that this implementation of the function ignores the case of the incoming keys, so if your second parameter were "abcdefg", the function would also allow "ABCDEFG" to be entered.

As an added bonus, CurrComboData protects you from the runtime error generated if ListIndex is -1. Just be sure to check for a return of -1 from CurrComboData.

You can change the MaxLength value to any number you want. As you can see, the code allows the user to use the [Backspace] key; you could enable other keys by simply adding their KeyAscii values the way we did with [Backspace].

Call ClearAllControls(Me)

Editor's Note: A similar tip was submitted by Alan Brown, algernon@btinternet.com.

When you launch Visual Basic 4 or 5, any active Add-Ins also launch. If there's an error in one of the Add-Ins, however, you could encounter a global protection fault.

To prevent this from happening, you can turn off Add-Ins before launching VB. To do so, launch Notepad or WordPad and open the file VBAddin.INI in your Windows directory. You'll see a series of entries like this:

AppWizard.Wizard=1

Just change the "1" to a "0" in each entry. Then save the file and launch VB. The program will launch without any Add-Ins.

Of course, to add and remove Add-Ins while you're in Visual Basic, just choose Add-In Manager from the Add-Ins menu.

You can easily switch an object's Enabled property with a single line of code:

optSwitch.enabled = abs(optSwitch.enabled) - 1

Here's how the technique works: When Enabled is True, its numeric value is -1. The absolute value of -1 is 1, so subtracting 1 from 1 would yield 0, which is False. When Enabled is False, its numeric value is 0; 0 - 1 would then yield -1, or True.

This technique is an enhancement of the common usage

fraOption.enabled = optSwitch.enabled

to have an object follow the value of any other object's Enabled property.

Editor's Note: This technique depends on VB's definition of True and False. To make this technique less dependent on that definition, you can use the following code:

OptSwitch.enabled = NOT OptSwitch.enabled

This code works for any Boolean data type.

By default Access string fields contain NULL values unless a string value (including a blank string like "") has been assigned. When you read these fields using recordsets into VB string variables, you get a runtime type-mismatch error. The best way to deal with this problem is to use the built-in & operator to concatenate a blank string to each field as you read it. For example,

Dim DB As Database
Dim RS As Recordset
Dim sYear As String

Set DB = OpenDatabase("Biblio.mdb")
Set RS = DB.OpenRecordset("Authors")
sYear = "" & RS![Year Born]

Editor's note: A similar tip was also sent in by Fran Arreciado, franac@cinsa.es

In Windows 95, right-clicking any text box brings up a context menu with basic edit commands on it. If you want to change this menu, put the following code in the MouseDown event of the text box.

If Button = vbRightButton Then
     Text1.Enabled = False
     Text1.Enabled = True
     Text1.SetFocus
     PopUpMenu Menu1
End If

where Text1 is the text box and Menu1 is the pop-up menu.

Disabling and re-enabling the control causes Windows to lose the MouseDown message, SetFocus tidies things up a bit, and PopUpMenu shows the menu.
Left clicks will work as always, allowing the user to edit the text in the text box.

You can easily retrieve a user's network logon name by using the following API call:

Declare Function GetUserName Lib "advapi32.dll" Alias "GetUserNameA" _
(ByVal lpBuffer As String, nSize As Long) As Long

To retrieve a "clean" version of the name, use this function:

You can easily prevent users from running multiple instances of your programs by taking advantage of the PrevInstance property of the App object.

To do so, enter the following code in your application's opening form:

If App.PrevInstance Then
    MsgBox ("Cannot load program again."), vbExclamation, "The requested " _
    & "application is already open"
    Unload me
End If

This technique will also prevent multiple users from accessing single-user applications.

If you want to convert text to uppercase as it's entered in a text box, just create an Upper function and call it from the text box's keypress event, as shown here:

     Private Sub Text1_KeyPress(KeyAscii As Integer)
        KeyAscii = Upper(KeyAscii)
    End Sub

    Function Upper(KeyAscii As Integer)
        If KeyAscii > 96 And KeyAscii < 123 Then
            KeyAscii = KeyAscii - 32
        End If
        Upper = KeyAscii
    End Function

This technique eliminates the need to "UCase" entered data. It also makes "hotseek" data searches much easier.

In VB, the Text property of a Combo box whose Style property is set to '2 - Dropdown List' is read-only. This means that a statement like MyCombo.Text = "The Third Item" will return an error if "The Third Item" is not part of the list. Wouldn't it be nice if VB just set the Combo box's ListIndex property to -1 (blanking it out) instead of bombing out? Well, here's some code that will do just that:

Function SetComboText(MyCombo as ComboBox, MyItem as String) as Integer
    Dim I as Integer

    For I = 0 to MyCombo.ListCount - 1
        If MyCombo.List(I) = MyItem Then
            SetComboText = I
            Exit Function
        End If
    Next I

    ' If the program reaches this point, the string is not in the
    ' list.
    SetComboText = - 1
End Function

Use the function like this:
AnyCombo.ListIndex = SetComboText(AnyCombo, "Any String") If "Any String" is in the list, then the combo box's ListIndex will be set to the correct index; if not, it will be blanked out. The great thing about this code is that if you want to do something else other than blanking out the combo box, all you have to do is replace the line SetComboText = - 1 with whatever you wish.

Sometimes you need to write a program that builds up a large amount of data in a string variable. You'd normally use a statement such as

strBuffer = strBuffer & strNewData

during every loop. The problem with this approach is that the bigger your string buffer becomes, the slower your program runs.

A neat and very simple way around this problem is to use another buffer. Just fill the temporary buffer with data, and when it's big enough, append it to the main buffer. Then, clear the temporary buffer and continue. The code will look like this:

Public Sub NewBuildBuffer()
     Dim strBuffer As String, strTemp As String
     Dim l As Long, dStart As Date

     'Set start time
     dStart = Now

     'Build the buffer
     For l = 1 To 10000
          strTemp = strTemp & "New Line" & vbCrLf
          'Append to the main buffer every 100 times
          If l Mod 100 = 0 Then
               strBuffer = strBuffer & strTemp
               strTemp = ""
          End If
     Next
     'Append the last temp buffer
     strBuffer = strBuffer & strTemp

     'Report total time
     MsgBox "Seconds taken = " & DateDiff("s", dStart, Now)
End Sub

For programs that use very large string buffers, you'll see a huge improvement.

Have you ever tried looking for a property in the properties window by typing in the first letter of the property's name? The properties window doesn't work this way.

Here's a tip that will help. In the properties window, hold down [Ctrl][Shift] while pressing the letter you're looking for. The properties window will then scroll to the next property (if any) that begins with the letter.

To center a form on the screen in VB3 or VB4, you can write a CenterForm subroutine. Then, call CenterForm in the form's Load event. The code is as follows:

Public Sub CenterForm(frmTarget As Form)
     frmTarget.Move (Screen.Width - frmTarget.Width) / 2, _
          (Screen.Height - frmTarget.Height) / 2
End Sub

Private Sub Form_Load()
     CenterForm Me
End Sub

Editor's Note:
In VB5, you can center a form on the screen by setting the StartUpPosition property of the form to CenterScreen or CenterOwner.

Sometimes when you display a form, only some of the controls appear. After a pause, the remaining controls appear. Such partial painting doesn't look professional. (Fortunately, this problem is much less apparent in VB 5.0 because of dramatic improvements in screen painting.)

To avoid partially painted windows when showing a non-modal form, use the following code:

frmPerson.Show vbModeless
frmPerson.Refresh

The Refresh method will ensure that the form repainting is complete before executing any other code in the routine.

Suppose you want to use a resource file (RES) in your Visual Basic project, but some of the file's resource indexes are greater than 0x8000. The VB function LoadResString(index) receives an integer argument Index in the range -32,768 to 32,767, so you can't pass values that are larger than 0x8000. You can solve this problem by passing the corresponding negative index value, as follows (with 0 <=X < 0x8000):

RES	Visual Basic
0xFFFF - X	-X - 1
0x8000+X	X-0x8000

 
For example, suppose you have the following RC file:

     STRINGTABLE DISCARDABLE
     BEGIN
       0xFFFF-0x0000         "resource string 1 with VB index -0 - 1 = -1"
       0x8000+1              "resource string 2 with VB index 1 - 32,768= -32,767"
     END

To load string 1, you'll use LoadResString(-1). Similarly, to load string 2 you'll use LoadResString(-32767).

The Val() function is familiar, and it's useful for converting text box numeric values to numbers. But if you use formatters to display large numbers (with commas, for instance), there's a better function for your purpose. The following example illustrate the use of Val versus CDbl:

     print Val("12345")
        12345
     print Val("12,345")
        12
     print CDbl("12,345")
        12345
     print CDbl("12345")
        12345

Why are these functions different? The Visual Basic Help file offers several hints. You should use the CDbl function instead of Val to provide internationally aware conversions from any other data type to a Double. For example, CDbl will recognize different decimal separators and thousands separators properly depending on your system's locale.
Also, if you want your display and input routines to be automatically reversible, you may want to consider using named formatters for FORMAT$() rather than display pictures. Doing so helps guarantee a reversible process, given the LOCALE setting of the user's machine.

The following code sample demonstrates an easy way to display and process a message box (MsgBox) in any version of Visual Basic:

     Select Case MsgBox("Would you like to save the file somefile.txt?", _
     vbApplicationModal + vbQuestion + YesNoCancel, App.Title)
       Case vbYes
          'Save then file
       Case vbNo
          'Do something for No
       Case vbCancel
          'Do something else for Cancel
     End Select

This method works well, unless you need to save the answer from your Select Case for later use. If you do, you'll need to use the more standard form of prompting for the answer in a variable.

I recently came across a serious inefficiency in the way Visual Basic sends strings to a DLL. The problem occurs when you want to get back a large string field (32 KB) from a DLL written in C/C++. VB interacts somehow with this string, causing significant overhead. In order to call a DLL and get back a string-type data field, you must pass a string and initialize it for as many bytes as you expect to be returned. If you pass this function a small string, it will run quickly. But if you pass it a large string (32 KB), the time will be significantly slower. You'll see this slower performance even when no data is being returned, meaning that the extra time results from some sort of VB overhead. As a result, if speed is an issue when you're calling a DLL and passing a string variable, you should pass a string that's only as large as you need.
You can find a sample project that demonstrates this problem in the file Speed.zip at ftp.cobb.com/ivb/tipcode. The project simply loops for a predetermined number of times and issues the standard windows API call GetPrivateProfileString, which gets data from an INI file.

To create a VB program that has only console input and output -- that is, no dialog boxes or forms -- you can use the Main procedure. Begin by creating a new project. Open a code window, then choose Insert | Procedure…. In the Insert Procedure dialog box, Select the Sub and Public options and enter Main in the Name box. Click OK to create a new Main subroutine in the General object. All your code will go in this routine; if you have any useful BAS modules, you can add those to the project as well.
VB needs to know what code to execute when your application is called. Since you're not using a form, you need to tell VB to start execution with Sub Main. To do so, choose Tools | Options…. Click the Project tab and select Sub Main from the Startup Form list. To remove the project's default form, right-click on it in the Project window and choose Remove File from the speed menu.
Testing a formless application can be a headache, so plan ahead: Use a log file to get debug messages from your application. You'll want to read about the Print # statement in VB's Help file, along with Open and Close.
Note that you can use this method to create a VB application that will run as a service on NT. (Services can't have any forms or dialog boxes.)

Here's a quick and easy way to make a text box read-only. Simply enter the line

     keyascii = 0

in the textbox_keypress event.

Here's a cool technique for loading a combo box with the months of a year:

     'Load Months Combo
     For i = 1 To 12
       cmbMonth.AddItem Format("28/" & i & "/1997", "mmmm")
     Next

To see which month the user clicked, you can use the following code:

     Private Sub cmbMonth_Click ()
     Dim myRs as recordset
       .
       .
       .
       myRs!Month = cmbMonth.listindex + 1
     Next

I've recently taken over a project from someone else, and I've been left with code that has few naming conventions and a lot of bugs. I often find myself stepping through code wanting to check the value of a field. Unfortunately, I don't know the field's name—it could be Name, UserName, NameUser, txtName, and so on. It's a real pain to stop the program, click on the control in question, press [F4], get the control name, start the program again, and return to the point in the code where I was before. Here's a handy trick to get the control name right away.
At runtime, set the focus to the control in question. Then, click the Break button on the VB toolbar, type

   ?Screen.ActiveControl.Name

in the debug window, and press [Enter]. Voila! VB displays the control name in the debug window—and you didn't have to stop the program.

Suppose you want to use Visual Basic to create an EXE that takes an input value in a format like test.exe 2. Depending on the input value, you'll perform certain tasks. In this situation, you can make use of the Command function, which returns the argument portion of the command line you use to launch VB or an EXE you develop in VB.

It's easy to send command-line information to an application. For instance, to send information to an application called HappyApp, you could use the line

HappyApp /CMD 1972

Now, within the application—probably in the Sub Main—you can use the Command function to capture that command-line information.

To see this technique work, place a text box on a form. In the Form_Load event, place the following line:

Text1.Text = Command

While still in VB, place some code on the command line. To do this in VB 3.0, choose Options | Project; in VB 4.0, choose Tools | Options…, then click the Advanced tab; in VB 5.0, choose Project | Project Properties, then click the Make tab. Next, type This is my argument in the Command Line Arguments section and click OK. Run the application, and your command-line text will appear in the text box.

Note that if you're working with 32-bit VB, you may want to create an ActiveX EXE or ActiveX DLL (formerly OLE Automation servers). By doing so, you simply deal with property settings.

You can compile an OLE server as an OLE Dynamic Link Library (DLL) or an executable (EXE) file. Compiling as a DLL creates an in-process server, while compiling as an EXE file creates an out-of-process server.

In-process servers run in the client's address space; for this reason, in-process servers are faster than out-of-process servers. On the other hand, because out-of-process servers run in their own address space, they have capabilities that are unavailable with in-process servers. For instance, they can run asynchronously. (An asynchronous process can display modeless forms and run in the background.) In deciding whether to use an in-process or an out-of-process server, you'll need to consider the tradeoff between speed and flexibility.

The Name property can be very useful when you're validating data. For instance, suppose you have a data input screen with three text fields, and you want to be sure the user has entered a valid date in each control. The trick lies in placing the word Date in the name of every text control that will contain date-type data—for this example, create such a form and name the text fields txtDateOfBirth, txtHireDate, and txtDateLastReview.

Add an Update command button to the form, and place the following code in its Click event:

If Not ValidDates() Then
 MsgBox "Some of the dates entered are invalid"
 Screen.MousePointer = vbDefault
 Exit Sub
End If

Notice that since this block leaves the sub early via the Exit Sub statement, you must reset the mouse pointer to its default shape.

Next, enter the following ValidDate function, which uses VB's built-in Controls array:

Private Function ValidDates() As Boolean
Dim ctl As Control
Dim bInValid As Boolean

For Each ctl In Me.Controls
 Debug.Print ctl.Name
 If TypeOf ctl Is TextBox Then
  If InStr(1, ctl.Name, "Date") > 1 And _
   ctl.Text <> "" Then
   bInValid = Not IsDate(ctl.Text)
   If bInValid Then
    ValidDates = False
    Exit Function
   End If
  End If
 End If
Next
ValidDates = True
End Function

Run the project and enter the values 2/7/64, 7/8/93, and To be scheduled in the three fields. When you click Update, a message box will inform you that a date is invalid. Click OK, then enter 10/31/96 in the Date Of Last Review text box—this time, VB won't object when you click Update

To quickly indent an entire block of Visual Basic code, select the text and press the [Tab] key. You can just as easily move a code block out one tab stop by selecting the text and pressing [Shift][Tab].

Suppose you want to use a generic routine to get the name of a field to assign to a variable, while using OLE to write the records of an Access database to an Excel worksheet. Once you have an open recordset—let's call it rsMine—the lines

sString = rsMine.Fields(0).Name
sString = rsMine.Fields(1).Name

retrieve the first two fields names. You'll normally loop through the recordset and match the grid columns with the fields in the database. But be cautious—often the field name isn't a good title for the grid. The end user also may not understand a developer's naming conventions.

For example, place a Grid control on a form and select the Microsoft DAO 2.5/3.0 Compatibility Library option in the References dialog box. Then enter the following code, which is written in VB 4.0 syntax and uses the BIBLIO.MDB database. The code finds the names of the database fields, then enters those names into the grid columns. Notice that you use a Forward Only snapshot type recordset, which is very fast and very small. Since you'll read and move on, you don't need to scroll through the recordset.

Option Explicit

'Set form-level DB variable for this example
Private dbCurrent As Database

Private Sub Form_Load()
Dim rs As Recordset
Set dbCurrent = OpenDatabase("C:\Program Files\Microsoft Visual Basic\biblio.mdb")
Set rs = dbCurrent.OpenRecordset("Publishers", dbOpenSnapshot, dbForwardOnly)
If rs.RecordCount <> 0 Then
  ColumnNames rs, Grid1
End If
End Sub

Private Sub ColumnNames(rs As Recordset, grd As Grid)
Dim fld As Field
Dim iCol As Integer
iCol = 0
grd.Cols = rs.Fields.Count
grd.Row = 0
For Each fld In rs.Fields
  grd.Col = iCol
  grd.Text = fld.Name
  iCol = iCol + 1
Next
End Sub

If you find that your application loads slowly, you may be loading more than you think at start-up. Try the following steps to correct the problem: Load your application in Visual Basic's design mode and press [F8] to start it. Keep pressing [F8] to run your code one line at a time, and observe what's really going on as your code executes. For example, suppose your Sub Main() code looks like this:

frmSplash.show vbModal
frmMain.show

You may feel confident that you won't execute (or Load) the frmMain code before the user sees the splash screen. But if your splash screen reads application parameters, and those routines set properties on frmMain--perhaps you save the user's frmMain screen color choices between runs, or save the application's WindowState--then frmMain will silently (and slowly) load in the background while frmSplash tries to display itself.

You may also experience slow loading if you call the same routine several times from different places during your start-up process. For example, in heavily maintained code, it isn't impossible for the application to load the application's parameters in a splash screen and again later for use within frmMain. Removing the extraneous, repeated call saves that much time in loading. (There are a number of places where you may find duplicate code, especially if you copy lots of forms and modules from one application to start another.)

An auto-searching combo box finds a possible selection as the user enters information directly into the text portion of the combo box. For this example, you can use the Authors table from Visual Basic's BIBLIO.MDB database. Place the following code in a standard module (BAS file):

Declare Function SendMessage Lib "user32" Alias "SendMessageA" _
(ByVal hwnd As Long, ByVal wMsg As Long, ByVal wParam As Long, _
lParam As Any) As Long

Public Const CB_FINDSTRING = &H14C

(If you're using 16-bit VB, make the appropriate adjustments to the declare statement.)

You'll need a static variable-one that remembers its value from each previous call to that subroutine or function-to keep track of how many characters you've entered in the combo box at any given time.

Enter the following code in the combo box's Change event:

Private Sub Combo1_Change()
Dim iStart As Integer
Dim sString As String
Static iLeftOff As Integer
 
iStart = 1
iStart = Combo1.SelStart
 
If iLeftOff <> 0 Then
  Combo1.SelStart = iLeftOff
  iStart = iLeftOff
End If

sString = CStr(Left(Combo1.Text, iStart))
Combo1.ListIndex = SendMessage(Combo1.hwnd, _
 CB_FINDSTRING, -1, ByVal CStr(Left( _
 Combo1.Text, iStart)))

If Combo1.ListIndex = -1 Then
 iLeftOff = Len(sString)
 Combo1.Text = sString
End If

Combo1.SelStart = iStart
iLeftOff = 0
End Sub

The static variable iLeftOff helps determine how many characters you need to use in the sString variable that you then pass to the API call.

Run the application and notice how the cursor position stays at the proper position as you enter characters. The combo box displays a name if VB finds a match; otherwise, only the entered text appears.

After you run a DOS application in Windows 95, the MS-DOS Prompt window doesn't close. To prevent this behavior, you can use the API to find the Window handle for the DOS prompt window, wait for the program to finish running, then zap the DOS prompt window into oblivion.
This technique doesn't require any forms. It's just a simple VB 4.0 DLL with two properties: the EXE name of the DOS program and the text that will appear as the caption of the DOS prompt window displaying this application. The core of this app lies in three API calls. Place the following code in a standard module:

Declare Function FindWindow& Lib "user32" Alias "FindWindowA" _
(ByVal lpClassName As String, ByVal lpWindowName As String)

Declare Function SendMessage Lib "user32" Alias "SendMessageA" (ByVal hwnd As Long, _
ByVal wMsg As Long, ByVal wParam As Long, lParam As Any) As Long

Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)

Public Const WM_CLOSE = &H10

     Private m_sEXEName As String
     Private m_sDosCaption As String

     Public Sub RunDosApp()
     Dim vReturnValue As Variant
     Dim lRet As Long
     Dim i As Integer

     vReturnValue = Shell(m_sEXEName, 1) ' Run EXE
     AppActivate vReturnValue ' Activate EXE Window

     Do
      Sleep (10000)
      lRet = FindWindow(vbNullString, m_sDosCaption)
      If (lRet <> 0) Then
          vReturnValue = SendMessage(lRet, WM_CLOSE, &O0, &O0)
          Exit Do
      End If
     Loop
     End Sub

May 6, 1997
Determining whether a file exists
Visual Basic doesn't provide any built-in means for telling whether a particular file exists. However, you can use the DIR or DIR$ function to check a file's existence. Simply pass the filename to the DIR function and check the function's return value-if the function returns nothing (""), then there's no such file.
To try this technique, create a VB project, place a button on Form1, and enter the following code in the button's Click event:

Private Sub Command1_Click()
FileInQuestion = Dir("C:\AUTOEXEC.BAT")
If FileInQuestion = "" Then
  MsgBox "No such file!"
Else
  MsgBox "File exists!"
End If
End Sub

Sub CenterButtons(frm As Form, Control1 As Variant, Optional Control2 As Variant)

Sub CenterButtons(frm As Form, Control1 As Control, Optional Control2 As Control)
' VB5 code to center buttons across the bottom of the screen.
'
If Not frm.Visible Then Exit Sub
'
If IsMissing(Control2) Then
   ' you have only 1 button
...

Function InRunMode(VBinst As VBIDE.VBE) As Boolean
InRunMode = (VBinst.CommandBars("Run").Controls("End").Enabled = True)
End Function

Dim PControl As Object
Dim MyControl As Control
Dim AControl As Object
'Get my UserControl
For Each AControl In ParentControls
  If AControl.Name = Ambient.DisplayName Then
    Set MyControl = AControl
    Exit For
  End If
Next
'Get the Form UserControl is on
Set PControl = ParentControls.Item(1).Parent
While Not (TypeOf PControl Is Form)   Set PControl = PControl.Parent
Wend

Create a form containing a timer and an image list. Set the timer's Interval property to 2000, then use the ImageList control's Custom property to add three images. Finally, add this code to the Timer event:

Private Sub Timer1_Timer()
Static ilmage As Integer
ilmage = ilmage + 1
If ilmage > 3 Then ilmage = 1
Me.Icon = ImageList1.ListImages(ilmage).Picture
EndSub

Type TestUDT
Score As Integer
Player As String
End Type

and a Cgame class with properties for Score and Player. You'd pass each UDT member with code like this:

Private Sub SendUDT()
Dim xUDT As TestUDT
xUDT.Player = "Michael Jordan"
xUDT.Score = 45
PassUDT xUDT
End Sub

Public Sub PassUDT(Z As TestUDT)
Dim x as New Cgame
Cgame.Score = Z.Score
Cgame.Player = Z.Player
End Sub

Public Sub SelAllText() Screen,ActiveControl.SelStart = 0 Screen.ActiveControl.SelLength = Len(Screen,ActiveControl.Text) EndSub

You can also use a second method, which may give you more flexibility if you're going to use it with objects other than text boxes:

Public Sub SelAllText(ctl as Control) ctl.SelStart = 0 ctl.SelLength = Len(ctl.Text) EndSub

You can use this behavior to be sure your variable names are spelled correctly throughout your code. Change one occurrence of the name to all capital letters (for instance, MYVARIABLE) and all other occurrences will be automatically changed to match. Now, if you look through the code and see MyVarible, you know the name is spelled incorrectly.