You are on page 1of 50

Visual Basic (VB) is the third-generation event-driven programming language and integrated

development environment (IDE) from Microsoft for its Component Object Model(COM) programming
model. Visual Basic is relatively easy to learn and use.
Visual Basic was derived from BASIC and enables the rapid application development
(RAD) of graphical user interface (GUI) applications, access to databases using Data Access Objects and so
on.
Object has three characteristics and these are
1. Property
: represents (data) characteristic of an object.
2. Method
: represents the behavior (action) performed by an object.
3. Event : Event is message sent by an object to signal an activity.
Creating A Project
1.
Start VB6
2.
When presented with a "New Project" dialog you will usually want to pick "Standard EXE" and
press "Open"
3.
You now see the VB6 IDE, which contains an empty form called "Form1". That is your program.

Forms
In Visual Basic, the Form is the primary component of every GUI application. A form is a unique
kind of control, known as a top-level container, a control that can contain within it any number of controls.
Forms can come in many shapes and sizes, but typically they are solid gray boxes with a surrounding frame,
a caption bar, and a variety of clip controls (a context menu, a close button, a minimize button, etc.).
Create a form
Forms can be created quite easily by starting a new project and selecting "Add Form..." from the project
menu.
If you specify this form as your project's start-up object (from Project / Properties), when you run this code,
your form will appear, and the program will end when the form is closed.
Changing Properties of Objects
If you click on an object on your form, or even the form itself, you gain access to the properties of
that item and change them in the properties pane on the right side of the screen.
Running A Program
Take a look in the menu item "Run".
Page 1 of 50

You will find that:

Pressing "Start" in that menu, pressing the "Play" button, or pressing F5 on your keyboard will run
your program

Pressing "End" in that menu, or pressing the "Stop" button will stop your program.
Getting into the source code
Right-click anywhere on the form called "Form1", and select "View code". Another way to accomplish
the same thing is to double-click anywhere on the form.

Setting project properties

In the top menu click on Project Project1 Properties


Variables
A variable is a word or letter used to reference data used in a program.
Variable Names
The following are the requirements when naming the variables in Visual Basic:

It must be less than 255 characters

No spacing is allowed

It must not begin with a number

Period (.)is not permitted

In Visual Basic we define a variable name by using the keyword Dim. Dim stands for "dimension" which is a carry over from early programming days. When you define a variable, you also specify what
type of data it is allowed to hold. Below is a list of all the different data types and what data they can
hold.
General Data Types
TYPE

Can Hold

Boolean

True or False

Byte

A number 0 to 255

Double

A 64 bit floating point number (I.E. 3.1415) - This is used when a high degree of accuracy is
needed.

Integer

A whole number from -32768 to 32767

Long

A whole number from -2,147,483,648 to 2,147,483,647

Single

A 32 bit number like a double, but with less precision

Page 2 of 50

String

A collection of letters such as "Hello". This is used to store words and sentences.

Without using a variable


Private Sub Command1_Click()
' Execute a simple message box that will say "Hello, World!"
MsgBox "Hello, World!"
End Sub
Using variable
Private Sub Command1_Click()
Dim var1 As String
var1 = "Hello, World!"
MsgBox var1
End Sub
Private Sub Form_Load()
Dim a As Integer
Dim b As Integer
Dim c As Integer
a=5
b=5
c=a+b
MsgBox c
End Sub
MsgBox TextUser.Text & " " & TextPassword.Text
Unload FormLogOn
Or
Unload me
Option Explicit
Dim Count As Integer
Private Sub Form_Load()
Count = 0
Timer1.Interval = 1000 ' units of milliseconds
End Sub
Private Sub Timer1_Timer()
Count = Count + 1
Label1.Caption = Count
End Sub
A conditional statement
A conditional statement is a way for you to execute commands based on if a condition is true. With an ifstatement, you can evaluate an expression, and perform one task if that expression is True and perform
another if it's False.
Page 3 of 50

The If-Then Statement


If (Expression) Then
(Multiple lines of code to execute)
End If
Private Sub Command1_Click()
Dim var1 As Integer
var1 = 10
The If-Then-Else Statement
If (Expression) Then
(Code to execute if True)
Else
(Code to execute if False)
End If
If var1 = 10 Then
MsgBox "The condition is true."
End If
End Sub
Private Sub Command1_Click()
Dim var1 As Integer
var1 = 5
If var1 = 10 Then
MsgBox "The variable is ten"
Else
MsgBox "The variable is not ten"
End If
End Sub
pseudo code
1.
Let x = 1, let y = 0.
2.
Print x.
3.
Let x = y + x
4.
Let y = x - y
5.
Repeat from 2.
This pseudo code will print out: 1, 1, 2, 3, 5, 8, 13, 21, ... as expected.
LOOPS
Loops provide the ability to repeatedly execute the same block of code, and to each time change values such
that each run through the loop produces different results. Visual Basic provides four main kinds of loops: the
classic Do-Loop, the Do-Until Loop, the Do-While Loop, and the For-Next Loop.
Do-Loops
Page 4 of 50

The most basic form of loop in Visual Basic is the Do-Loop. Its construct is very simple:
Do
(Code to execute)
Loop

generating the Fibonacci series:


Dim X As Integer
Dim Y As Integer
Do
Debug.Print X
X=Y+X
Y=X-Y
Loop

Exit Do
So we clearly need some way to escape from the Do-Loop.
Public Sub Main()
Dim X As Integer
Dim Y As Integer
Dim cnt As Integer 'Our counter.
cnt = 1
Do
Debug.Print X
X=Y+X
Y=X-Y
If cnt >= 8 Then
Exit Do
Else
cnt = cnt + 1
End If
Loop
End Sub
Do While
In the place of Do Until, you can also use Do While. Its syntax is the following:
Do While (Expression)
(Code to execute)
Loop
Page 5 of 50

(Expression) can be any legal logical expression that we wish to evaluate to determine whether or not to exit
the loop. Each time the program reaches Loop it will verify that this expression is True, and if it is False, it
will exit the loop for us. Thus, instead of exiting when an expression is True, it now exits only once this
expression is false. Let's try rewriting our Fibonacci program to use a Do-While loop instead of a Do-Until
loop.
Public Sub Main()
Dim X As Integer
Dim Y As Integer
Dim cnt As Integer 'Our counter.
cnt = 1
Do While cnt < 8
Debug.Print X
X=Y+X
Y=X-Y
cnt = cnt + 1
Loop
End Sub
For-Next Loops
In situations where you merely want to run the loop a predefined number of times, it can become quite
tiresome to have to create and manage a counter for each loop, which is why we also have something called
a For-Next Loop. This kind of loop allows you to specify a counter, to tell it to count from one number to
another each time through the loop, and to exit once the counter has reached its upper limit. The syntax is as
follow:
Dim I As Integer
For I = (Integer) To (Integer)
(Code to execute)
Next I
We used the variable name "I" above, as it is the most common name used for For-Loops; however, you can
use any variable name you want, so long as the variable is of the type Integer. Now, let's improve our
Fibonacci program even further:
Public Sub Main()
Dim X As Integer
Dim Y As Integer
Dim cnt As Integer 'Our counter.
For cnt = 1 To 8
Debug.Print X
X=Y+X
Y=X-Y
Loop
End Sub
Page 6 of 50

In the example above, we first dimensioned cnt as an Integer, and then, in the declaration of the For-Next
loop, set its value to 1. Each time through the loop, the value of cnt was incremented by 1 until it reached 8,
at which point the loop was executed.
Exit For
As with Do Loops, there is a statement that can be used to exit a For-Next loop, and it is called Exit For.
Simply invoke this statement anywhere within a For-Next loop and the current loop will be exited.
Step
By default, the variable used in the declaration of the For-Next loop is incremented by 1 each time through
the loop; however, if you want to increment this value by a different amount each time through the loop, you
can simply append Step (Integer) to the end of the For-Next loop declaration. If, for instance, we wanted to
print out every even number counting backward from 20 to 0, we could do this using the following code:
Dim I As Integer
For I = 20 To 0 Step -2
Debug.Print I
Next I
Functions and subroutines
What Are Subroutines?
Subroutines can be thought of as miniature programs. A subroutine has a name attributed with it,
much like a variable does. Unlike a variable, a subroutine doesn't hold data. Instead, it holds code. When the
code in a subroutine is executed, the subroutine is said to be "called". Therefore, one subroutine can "call"
another subroutine. Some subroutines are called automatically when certain actions are performed. For
example, the Form_Load subroutine is automatically called when a form loads. This is where you have been
inserting your test code before. What you were actually doing was adding code to this subroutine.
A Note On Form_Load
Technically, Form_Load isn't really a subroutine, it is a special type of subroutine called an EVENT.
Why Use Subroutines?

eliminate redundancy.
making the entire program easier to manage.
debug the codes in more concise and efficient way.

Creating A Subroutine
Creating a subroutine involves two lines of code. A subroutine begins with the word "Sub", followed
by a space, then a name identifying the subroutine. Two parentheses follow, which are used for a parameter
list.
Sub TestSub()
End Sub
Page 7 of 50

After you enter the first line and press Enter, the second line will automatically be added for you.
These lines represent the start and end of the subroutine. Any code inserted between these lines will be
executed when the subroutine is called. A subroutine can be called in one of two ways: using the Call
keyword, or by simply stating its name.
Sub TestSub()
MsgBox "Code in TestSub()"
End Sub
Private Sub Form_Load()
MsgBox "Code in Form_Load()"
TestSub
MsgBox "Back in Form_Load()"
End Sub
You can also use the Call keyword, as mentioned above:
Sub TestSub()
MsgBox "Code in TestSub()"
End Sub
Private Sub Form_Load()
MsgBox "Code in Form_Load()"
'This line is functionally equal as the line in the previous example
Call TestSub
MsgBox "Back in Form_Load()"
End Sub
Comments
The previous listing introduced a new syntax element: the comment. A comment is a line that is NOT
source code. Instead, it is there as guidance to the person reading the code. When programmers write
programs, they usually (or at least they should) add comments describing large sections of code that could
potentially be confusing. Comments begin with an apostrophe ("'") and end with a new line. Everything that
you type after the apostrophe is ignored by Visual Basic, which is the entire point of comments. You will see
comments in all future listings describing new concepts and syntax.
Subroutine Scope
The declaration of a subroutine has an optional keyword that can be used before "Sub". You may enter a
keyword representing scope here. "Private" and "Public" are examples of scopes. You may have noticed that
the Form_Load subroutine has the word "Private" before "Sub". This declares that this subroutine has a
Private scope. If you don't specify the scope of a subroutine, Visual Basic will use a default scope. You
should never rely on default scope, however. Get in the habit of always explicitly declaring the scope of your
subroutines.
What Is Scope?
In the context of subroutines, scope represents where in your program the subroutine can be called
from. Subroutines with a Private scope can only be called from the source file from where they were
defined. Subroutines with a Public scope can be called from anywhere in your program. For example, a
Page 8 of 50

subroutine with a Private scope in a form can not be called from another form, whereas it can if it has a
Public scope.
Why Use Scope?
Why would you ever limit where you can call a subroutine from? Why wouldn't you make all subroutines
Public so that there are no limitations on your program? Subroutine Scope is one of many tools that
programmers can use to find bugs. If you know that your subroutine should never be called from a different
source file, you should declare the subroutine to be Private. This will prevent you from making a silly
mistake and calling this subroutine where it shouldn't be called. This will prevent mistakes that could be
extremely damaging and hard to detect. Instead, your program will crash with an error rather than executing
the subroutine with unpredictable results.
Parameters
Parameters, also called Arguments, are variables that can be "passed into" a subroutine. A subroutine with
parameters looks like this:
Private Sub DisplayAdd(x As Integer, y As Integer)
MsgBox x + y
End Sub
Private Sub Form_Load()
DisplayAdd 5, 2
End Sub
A new subroutine has been declared called DisplayAdd. This declaration is different than the declarations
that you have seen so far, however, as code has been added between the parenthesis. From your knowledge
of variables, this syntax should look somewhat similar to you. x As Integer and y As Integer appear to be
variable declarations without the "Dim" keyword. These declarations are separated by a comma. These
variables are the Parameters for the DisplayAdd subroutine. Code within the subroutine can access x and y
as usual, as if they were normal variables. However, when the subroutine is called, the calling subroutine
will also provide values for these parameters. Therefore, the subroutine has now become dynamic. The code
can act on input without caring where the input came from. When the Form_Load subroutine calls
DisplayAdd with the parameters 5 and 2, the code within DisplayAdd is executed. The first line adds x and y
together and displays the result. x and y have already been filled with the values 5 and 2 from the
Form_Load subroutine. The calling subroutine doesn't have to use numeric constants, however. It can use
variables as well:
Private Sub DisplayAdd(x As Integer, y As Integer)
MsgBox x + y
End Sub
Private Sub Form_Load()
Dim a As Integer
Dim b As Integer
a=5
b=2
DisplayAdd a, b
End Sub
Page 9 of 50

This code has identical results. Note that DisplayAdd cannot access a and b. As far as DisplayAdd is
concerned, a and b are represented as x and y. Attempting to access a or b from DisplayAdd would result in
an error.
ByRef and ByVal
Parameters can be sent to a subroutine By Reference (ByRef) or By Value (ByVal). ByRef is the default, and
means that changes to the variable in the subroutine will result in changes to the source variable outside of
the subroutine. ByVal literally copies the values of the variables from the calling subroutine into the called
subroutine. By doing this, the variables can be changed, but their values will not change outside of the called
subroutine. ByVal can also be a lot slower with large variable types, however, since memory has to be
copied from one location to another. If you don't have any reason to do so, there is no need to pass variables
ByVal. You can explicitly state the way that a variable is passed to a subroutine by using these keywords
before the variable name. Using the ByRef keyword, one could write a Swap function, which switches the
values of 2 variables.
Private Sub Swap(ByRef x As Integer, ByRef y As Integer)
Dim temp As Integer
temp = x
x=y
y = temp
End Sub
Private Sub DisplayVals(ByRef a As Integer, ByVal b As Integer)
'Don't worry about understanding the next line yet, it will be explained later
MsgBox "a = " & CStr(a) & vbCrLf & "b = " & CStr(b)
End Sub
Private Sub Form_Load()
Dim a As Integer
Dim b As Integer
a = 10
b = 12
'Display values, swap, and display again
DisplayVals a, b
'The next line is functionally identical to "Swap a, b"
Call Swap(a, b)
DisplayVals a, b
End Sub
Notice that Call was used instead of simply stating the subroutine name. When using the Call method
however, you must use parenthesis when calling the subroutine. Note that this program would also have
worked without typing "ByRef" anywhere, since it is the default. The ByRef and ByVal keywords are rarely
used in simple programs, however, but it's a nice trick for your toolkit.
Functions

Page 10 of 50

Subroutines have a close cousin called Functions. Functions are basically the exact same as subroutines,
except that they return a value. That means that the function itself has a type, and the function will return a
value to the calling subroutine based on the code that it contains. An example of this would be a function
that adds two numbers, shown below. A function is declared the exact same way as a subroutine, except
using the "Function" keyword instead of "Sub". To return a value, assign a value of the proper type to the
function's name, as if it were a variable.
Private Function Add(ByVal x As Integer, ByVal y As Integer) As Integer
Add = x + y
End Function
Private Sub Form_Load()
Dim a As Integer
Dim b As Integer
Dim c As Integer
a = 32
b = 64
c = Add(a, b)
MsgBox c
End Sub
Functions Or Subroutines?
The best way to determine which is better for your application is by asking yourself a simple question. Will
you need to return a value? If so, use Functions. If you don't, use subroutines.

Overview
If you've read some other beginner visual basic tutorials on this site, you're probably saying to yourself, "I
thought this was supposed to be Visual Basic!" Indeed, Visual Basic is very much so an interface-oriented
language, far moreso than other languages, and designing even complex graphical user interfaces (or GUIs)
is quite simple.
In contrast to tradional, command-line interfaces, almost all user interfaces in Visual Basic are constructed
using the WIMP, or "windows, icon, menu, pointer," GUI style. This means that Visual Basic programs
interact with users almost exclusively using graphical elements, such as windows, buttons, toolbars, etc.,
with very few console-based applications (in fact, creating a console-based VB application is quite difficult,
requiring advanced API techniques, which will be covered much later). While in previous lessons, we've
made use of Debug.Print, which is not a WIMP element, it's important to note that the debugging, or
intermediate, window is only visible in design mode, and not during typical program execution.
In this tutorial, we'll introduce and expand upon three basic methods of creating WIMP interfaces in Visual
Basic: using the MsgBox function (which you've seen before), the InputBox function, and forms and
controls.
MsgBox revisited

Page 11 of 50

Up until now, we've blindly used this magical MsgBox function to display text without really understanding
what it was, how it worked, or what could be done with it. Now that we have a bit more understanding of
functions, subroutines, and control structures, let's take a somewhat closer look at it.
MsgBox is a actually a function, like many of the functions we've used and created before, provided by the
standard VB runtime. Its function declaration is the following:
Public Function MsgBox( _
ByVal prompt As String, _
Optional ByVal buttons As Integer = vbOKOnly, _
Optional ByVal title As String = Nothing _
Optional ByVal helpfile As String = Nothing _
Optional ByVal context As Integer = Nothing _
) As Integer
Having read Functions and Subroutines in VB6, you should now be able to recognize a few useful attributes
of the MsgBox function. For one, MsgBox has a return type--Integer, which implies that we can not only
display data in a MsgBox, but also get information back. The information we are able to retrieve from
calling the MsgBox function is a numerical expression equating to a constant value that describes which
button on the MsgBox was clicked. Legal return values for the MsgBox function are: vbOK, vbCancel,
vbAbort, vbRetry, vbIgnore, vbYes, and vbNo.
Furthermore, we can specify which buttons and styles we want displayed on our message boxes using the
"buttons" argument. If, for instance, we want to display a msgBox with the buttons "Abort," "Retry," and
"Ignore," we can use the construct: MsgBox "Test", vbAbortRetryIgnore. If we further want to display this
message box with a "Question" icon, we can use this construct: MsgBox "Test", vbAbortRetryIgnore +
vbQuestion. There are many possible values for the button argument, and you can find a full list in the
MSDN library.
With the title argument, we can also change the text we want to display in the caption of the message box by
passing any legal String. The "helpfile" and "context" arguments will be explained later on in the course
when we cover contextual help in VB6.
MsgBox examples
Now let's took a look at a simple example that makes use of MsgBox.
Public Sub Main()
If MsgBox("Click a button.", vbOKCancel, "MsgBox Test") = vbOK Then
MsgBox "You clicked OK!", vbOKOnly, "MsgBox Test"
Else
MsgBox "You clicked Cancel!", vbOKOnly, "MsgBox Test"
End If
End Sub
And voila! We have a program that's capable of responding to user input! Now what if we to give the user
three different options? We could do this:
Public Sub Main()
If MsgBox("Click a button.", vbYesNoCancel, "MsgBox Test") = vbYes Then
Page 12 of 50

MsgBox "You clicked Yes!", vbOKOnly, "MsgBox Test"


ElseIf MsgBox("Click a button.", vbYesNoCancel, "MsgBox Test") = vbNo Then
MsgBox "You clicked No!", vbOKOnly, "MsgBox Test"
Else
MsgBox "You clicked Cancel!", vbOKOnly, "MsgBox Test"
End If
End Sub
However, you may notice one major probelm with this code: it displays two message boxes instead of just
one, which is what we expected. This is because each time you call MsgBox, a new message box is created.
To respond to three different return types for one MsgBox, it's best to store the value in a variable and then
perform tests on that variable. For example:
Public Sub Main()
Dim ret As Integer
ret = MsgBox("Click a button.", vbYesNoCancel, "MsgBox Test")
If ret = vbYes Then
MsgBox "You clicked Yes!", vbOKOnly, "MsgBox Test"
ElseIf ret = vbNo Then
MsgBox "You clicked No!", vbOKOnly, "MsgBox Test"
Else
MsgBox "You clicked Cancel!", vbOKOnly, "MsgBox Test"
End If
End Sub
InputBox
Now let's take a quick look at a function similar to MsgBox that allows the user to provide a much, much
wider array of valid inputs, namely the InputBox function. This function is provided by the standard VB6
runtime, and its declaration is as follows:
Public Function InputBox( _
prompt As String, _
Optional title As String = Empty, _
Optional default As String = "", _
Optional xpos As Single = Empty, _
Optional ypos As Single = Empty, _
Optional helpfile As String = Empty, _
Optional context As Integer = 0 _
) As String
This function displays an InputBox, or a single dialog requesting a single line of ASCII input from the user,
with the given prompt, title, default text (specified by default), and other argument values (which we won't
get into in depth) and returns the String that the user provided the dialog. Let's take a look at a simple
example:
Public Sub Main()
Dim YourName As String
YourName = InputBox("Please enter your name.", "InputBox demo")
Page 13 of 50

If Len(YourName) > 0 Then


MsgBox "Your name is " + YourName
Else
MsgBox "You hit cancel or entered an empty string."
End If
End Sub
This simple little program prompts the user for his or her name and then displays it in a MsgBox. If the user
selected cancel the string returned will be an empty string (""). This very simple function now allows your
program to behave in an infinite number of ways, as the InputBox dialog can except an infinite number of
various inputs.

Properties of forms
Like all controls, forms have a variety of properties associated with them. Some of these properties can be
set at runtime or by modifying them in the Properties Window. To access the Properties Window, simply
select the Form (in design mode, of course), and you should see the properties for the form appear in the
right-most docking-window directly beneath the Project Explorer. From here, you can change almost every
property of your form.
The most important property of a form is its Name. This property can be set only at design, and should
appear as the first item in the properties list. You can set this to anything you want; however, it is common
convention that all form names begin with a form identifier, such as "Form" or "frm". By default, the first
form in a project is named "Form1," the second "Form2," etc. Choosing a clear, descriptive name for your
forms is very important because everytime you call methods on or change the properties of a form from
runtime, you will use the form's name as an identifier.
Another important property of a form is its Caption. This property specifies what text will be displayed in
the form's caption bar. You can change it by selecting "Caption" from the properties list, and then specifying
any single line of text you would like. You can adjust the width and height of your forms by either explicitly
specifying the property in the Properties Window or by simply resizing the form in design mode. There are
many other physical properties of forms that we won't get into here, but please, feel free to play around with
them.
Form modules
So far, every VB6 application we've dealt with has been executed from a Basic module (or .bas file), by
creating a project, adding a new module, and adding to that module a Public Sub Main(). In traditional
BASIC, all programs were constructed this way; however, with the advent of Visual Basic a new kind of
module, known as a form module, was introduced. A form module is a unique kind of module that contains
code that is owned by one, and only one, form. Every form has one, and only one, form module associated
with it, and form modules contain all of the code that can be directly invoked by the form or by controls
contained by the form in response to an action by the user. The code in these modules can only be accessed
once the form is constructed, and form modules typically contain primarily only Private subroutines and
functions, though they may also contain Public helper routines to allow accessibility to components of the
form to other modules.
Page 14 of 50

To access a form's code module, simply select the form in the Project Exlporer, right-click, and select "View
Code." This will open up an empty editor window like we're used to seeing with Basic modules--the only
difference is what we can put in a form module. The most common starting point for a form is Private Sub
Form_Load(). This routine is called immediately after the form is created and drawn, but before the form has
begun waiting for user input. To start, let's try rewriting an example you've seen before to use Form_Load()
instead of Main():
Private Sub Form_Load()
MsgBox "Hello, world!"
End Sub
Immediately after this form is loaded, a MsgBox will be displayed with the text "Hello, world!". It is
important to note that every form can have a Private Sub Form_Load() and that, unlike with Sub Main, the
Form_Load routine can be accessed only by the form module (due to its Private access).
The "Me" identifier Now let's say we want to access the properties and methods of our form from within our
form module. We could use something like Form1.Caption = "Hello, world!", but this is very bad practice,
as you'll understand fully once we begin dealing with ActiveX controls and control arrays (much later on!).
Instead, Visual Basic provides an identifier known as the "Me" ientifier, which is simialr to "this" in
languages such as C and Java. It allows us, basically, to access ourselves--that is, the form module it's used
in. For example:
Private Sub Form_Load()
Me.Caption = "Hello, world!"
End Sub
This will change the Form's caption to "Hello, world!" after the form is loaded, regardless of what property
we specified at design-time.
The Show and Hide Methods

The Show method of a form displays that form on the screen. If the form to be shown is not already loaded
into memory, the Show method will load it before showing it. The Show method is typically used to transfer
control from one form to another. The syntax is:

formname.Show

For example, if I am in Form1 and I want to display Form2, the syntax would be:

Form2.Show

When you display one form from another, you may want the user to complete work on that form before
returning to the first one. This does not happen automatically. By default, VB will display the second form
Page 15 of 50

and then continue executing code from the first form. To suspend execution of the first form until after the
second form is done with, add the keyword constantvbModal as an argument to the Show method. The
syntax is:

Form2.Show vbModal

The Hide method of a form removes the form from the screen (makes it invisible), but the form still remains
in memory. The syntax is:

formname.Hide

To refer to the form in which code is currently running (i.e. the "current" form, or the "active" form), you
can of course refer to the form by its name, as in the example above:

Form1.Hide

As an alternative, you can use the keyword Me. The keyword "Me" refers to the form in which code is
currently running:

Me.Hide

Finally, any time you want to execute a method of the form on itself, you can simply code the method name,
omitting the "formname." or the "Me.", as in:

Hide

The Load and Unload Statements

The Load statement loads a form into memory, but does not display it. When you code the Load statement
for a form, the Form_Load event of that form will be triggered. The syntax is:

Page 16 of 50

Load formname

The Unload statement removes a form from memory and from the screen. When you code the Unload
statement for a form, the Form_Unload event of that form will be triggered. The syntax is:

Unload formname

A form can unload itself, as in:

Unload Me

The Unload event is also triggered with the user clicks the Windows "close" button ("X") on the form.

Try this:

Place a command button named "cmdExit" with the caption "Exit" on a form. In the Click
event for the command button, instead of coding "End", code:

Private Sub cmdExit_Click()

Unload Me

End Sub

For the Form_Unload event, code the following:

Private Sub Form_Unload(Cancel As Integer)

If MsgBox("Are you sure you want to quit?", _


vbYesNo + vbQuestion, _
"Unload Test") = vbNo Then
Page 17 of 50

Cancel = 1
End If

End Sub

Run the program and observe what happens either when you click the Exit button, or
when you try to close the form by clicking on the "X" button.

Note that VB supplies the Unload event with a built-in argument called "Cancel". If, in the Unload event
procedure, you set the Cancel argument to any non-zero value, the Unload event will be cancelled (i.e., the
form will not be unloaded) and processing will continue. This event is where you might ask the user if they
are sure they want to quit. If they respond Yes, let the Unload event "do its thing"; if No, set Cancel to nonzero value.

Note: When all forms of a VB project are unloaded, the application ends. The End statement automatically
unloads all forms in a project, but will not trigger the Unload event (so any code you have in the Unload
event will not execute) therefore, ending an application with "End" does not give the user a second
chance to keep working with the program. The End statement ends the program abruptly.

Centering a Form on the Screen

The following code will center a form on the screen. It is best placed in the Form_Load event.

Me.Top = (Screen.Height Me.Height) / 2


Me.Left = (Screen.Width Me.Width) / 2

In VB project that has multiple forms, it is a good idea to centralize the form-centering logic in a Public Sub
procedure of a separate standard (BAS) module. The sub, which accepts a Form object as a parameter,
would look like this:

Public Sub CenterForm(pobjForm As Form)

With pobjForm
.Top = (Screen.Height .Height) / 2
Page 18 of 50

.Left = (Screen.Width .Width) / 2


End With

End Sub

With the above Sub in place, any form in the project can center itself with the following line of code:

CenterForm Me

Form_Load vs. Form_Activate

In the Form_Load event, you would typically perform initialization-type tasks, as you should. However,
certain types of actions cannot be performed in the Load event, due to the fact that the form is fully loaded
only after the Load event completes. For one thing, printing to the form will not work when done in the
Load event. In addition, if you try to set focus to a particular control on the form during the Load event, you
will get the message Run-time error '5': Invalid procedure call or argument. For example, assume you
had a textbox called Text1 on the form. The following code would result in that error:

Private Sub Form_Load()

' other initialization stuff

Text1.SetFocus ' causes an error

End Sub

The reason for the error is that since the form is not fully loaded, neither are any of the controls on it and
you can't set focus to a control that is not yet available.
To remedy this problem, you should use one of the other Form events, such as the Activate event. (When
VB loads a form, it actually cycles through a number of events, such as: Initialize, Load, Resize, Activate,
GotFocus, and Paint. Of these, Load and Activate are probably the ones most commonly used. ) Placing the
code to set focus to a control will work in the Form_Activate event:

Page 19 of 50

Private Sub Form_Activate()

' other statements

Text1.SetFocus ' no problem here

End Sub

A caution about the activate event: it will fire whenever your application switches to that form. For example,
if you switch back and forth between Form1 and Form2, be aware that any code you might have in the
Activate events for these forms will be executed when you switch to that form. Therefore, if you have code
in the Activate event that you only want to execute "the first time", you will need to control execution with a
Boolean switch. For example, in the General Declarations of your form you could define the following
variable:

Private mblnFormActivated As Boolean ' will be initialized to False by default

You can then use this switch in the Activate event as follows:

Private Sub Form_Activate()

If mblnFormActivated Then Exit Sub

' statements you only want to execute once, including the following
' statement to turn the switch on:

mblnFormActivated = True

End Sub

Multi-Form Projects
Page 20 of 50

Many projects will use more than one form. When you have more than one module (form or standard) in a
project, you must specify a "Startup object", which is done via the Project menu, Properties item. The startup
object tells VB which form or standard module is to have its code run first (if a standard module is the
startup object, it must contain a public subroutine called "Main", and "Sub Main" is specified for the Startup
object). By default, the startup object is the initial form that is supplied with every new VB Project.

Here are a couple of scenarios for projects with multiple forms:

(1)

You have an application that performs a variety of functions, requiring multiple "screens"
(forms). You can use one form as a "switchboard" or "main menu" form that connects to the other
forms.

(2)

You may wish to have a "splash screen" start off your application before the main form is
displayed.

Using Multiple Forms: "Switchboard" Example

Assume you have a project with three forms: Form1, Form2, and Form3. (To add forms to a project, go to
the Project menu and select Add Form.) Form1 serves as the switchboard form, which contains three
command buttons: cmdForm2, cmdForm3, and cmdExit:

The code behind these buttons is:


Page 21 of 50

Private Sub cmdForm2_Click()


Form2.Show vbModal
End Sub

Private Sub cmdForm3_Click()


Form3.Show vbModal
End Sub

Private Sub cmdExit_Click()


Unload Me
End Sub

For the sake of the example, Form2 and Form3 simply contain one button with the caption "Return to Main
Menu". The code behind the command button on each of these forms is simply Unload Me. When either of
these forms is unloaded, the main menu form will then become the active form.

Download the VB project code for the example above here.

*** BONUS MATERIAL ***


(Form Procedures)
Page 22 of 50

Presented below is a set of procedures that can be used to work with forms. The code presented can be saved
as a .BAS module (for example, modForm.bas) and can be included and used in any VB6 project.

The set of procedures is described below:

Procedure Name

CenterForm

Description

Centers a form on the screen. This Sub has been used in previous examples presented
site.

Usage: CenterForm FormName

(where FormName is the name of the form without quotes (e.g. Form1) or the keywo

To center the current form, you would use:


CenterForm Me

FormIsLoaded

Function that determines whether or not a form in your app is currently loaded. It doe
searching through the VB Forms collection. It accepts a string parameter containing t
the form that you want to check and returns a Boolean.

Usage: If FormIsLoaded("Form1") Then ...

EnableFormXButton

Sub that lets you enable or disable the form's "X" (or "Close") button that appears in
hand corner of the form's title bar. (A common usage is to disable the X button.) This
wrapper for a handful of APIs that work together to accomplish this task (GetSystem
GetMenuItemCount, RemoveMenu, DrawMenuBar).

Usage: EnableFormXButton FormName, BooleanValue


(where FormName is the name of the form without quotes (e.g. Form1) or the
keyword Me andBooleanValue is True or False)

Page 23 of 50

To disable the X button on Form1, you would use:


EnableFormXButton Form1, False

MakeTopmost

Sub that lets you keep a form "always on top", even if it does not currently have the f
Sub will also let you reverse the action and make the form "not" always on top. This
wrapper for the SetWindowPos API.

Usage: MakeTopmost FormName, BooleanValue


(where FormName is the name of the form without quotes (e.g. Form1) or the
keyword Me andBooleanValue is True or False)

To make the current form "always on top", you would use:


MakeTopmost Me, True

LockWindow /
UnlockWindow

The purpose of these Subs is help avoid "flicker" when controls and their contents ta
than usual to populate on a form. These Subs are a wrapper for the LockWindowUpd
which disables drawing in the given window. Only one window can be locked at a tim

Usage (to lock): LockWindow FormName.hwnd


Usage (to unlock): UnlockWindow

The code is given below:

Option Explicit

Private Declare Function DrawMenuBar Lib "user32" (ByVal hwnd As Long) As Long
Private Declare Function GetSystemMenu Lib "user32" (ByVal hwnd As Long, ByVal bRevert As Long) As
Long
Private Declare Function GetMenuItemCount Lib "user32" (ByVal hMenu As Long) As Long
Page 24 of 50

Private Declare Function LockWindowUpdate Lib "user32" (ByVal hwnd As Long) As Long
Private Declare Function RemoveMenu Lib "user32" (ByVal hMenu As Long, ByVal nPosition As Long,
ByVal wFlags As Long) As Long
Private Declare Sub SetWindowPos Lib "user32" (ByVal hwnd As Long, ByVal hWndInsertAfter As Long,
ByVal X As Long, ByVal Y As Long, ByVal cx As Long, ByVal cy As Long, ByVal wFlags As Long)

Private Const MF_BYPOSITION As Long = &H400&


Private Const MF_REMOVE As Long = &H1000&
Private Const HWND_TOPMOST As Long = -1
Private Const HWND_NOTOPMOST As Long = -2
Private Const SWP_NOSIZE As Long = &H1
Private Const SWP_NOMOVE As Long = &H2
Private Const SWP_NOACTIVATE As Long = &H10
Private Const SWP_SHOWWINDOW As Long = &H40

'=============================================================================
' Form-related Routines
'=============================================================================

'----------------------------------------------------------------------------Public Sub CenterForm(pobjForm As Form)


'-----------------------------------------------------------------------------

With pobjForm
.Top = (Screen.Height - .Height) / 2
.Left = (Screen.Width - .Width) / 2
End With

End Sub

Page 25 of 50

'----------------------------------------------------------------------------Public Function FormIsLoaded(pstrFormName As String) As Boolean


'----------------------------------------------------------------------------Dim objForm As Form
For Each objForm In Forms
If objForm.Name = pstrFormName Then
FormIsLoaded = True
Exit Function
End If
Next
FormIsLoaded = False

End Function

'----------------------------------------------------------------------------Public Sub EnableFormXButton(pobjForm As Form, pblnEnable As Boolean)


'-----------------------------------------------------------------------------

Dim lngSysMenuID As Long


Dim lngMenuItemCount As Long
' Get handle To our form's system menu
' (Contains items for Restore, Maximize, Move, Close etc.)
lngSysMenuID = GetSystemMenu(pobjForm.hwnd, pblnEnable)

If lngSysMenuID <> 0 Then


' Get System menu's menu count
lngMenuItemCount = GetMenuItemCount(lngSysMenuID)
If lngMenuItemCount > 0 Then
' Remove (hide) the "Close" item itself (the last menu item) ...
RemoveMenu lngSysMenuID, lngMenuItemCount - 1, MF_BYPOSITION Or MF_REMOVE
Page 26 of 50

' Remove (hide) the seperator bar above the "Close" item
' (the next to last menu item) ...
RemoveMenu lngSysMenuID, lngMenuItemCount - 2, MF_BYPOSITION Or MF_REMOVE
End If
End If
DrawMenuBar pobjForm.hwnd
End Sub

'----------------------------------------------------------------------------Public Sub LockWindow(hwnd As Long)


'----------------------------------------------------------------------------LockWindowUpdate hwnd
End Sub

'----------------------------------------------------------------------------Public Sub UnlockWindow()


'----------------------------------------------------------------------------LockWindowUpdate 0
End Sub

'----------------------------------------------------------------------------Public Sub MakeTopmost(pobjForm As Form, pblnMakeTopmost As Boolean)


'-----------------------------------------------------------------------------

Dim lngParm As Long


lngParm = IIf(pblnMakeTopmost, HWND_TOPMOST, HWND_NOTOPMOST)
SetWindowPos pobjForm.hwnd, _
lngParm, _
0, _
0, _
Page 27 of 50

0, _
0, _
(SWP_NOACTIVATE Or SWP_SHOWWINDOW Or _
SWP_NOMOVE Or SWP_NOSIZE)

End Sub
The TIMER Control

The Timer control allows you to perform a task at a specified interval or to wait for a specified length of
time.

Timer Example 1

Start a new VB project and place two command buttons and a timer control on the form. Set the
properties of the controls as follows:
Control Property Value
Command Button (Name) cmdStart
Caption Start Timer

Command Button (Name) cmdStop


Caption Stop Timer

Timer (Name) tmrTest


Enabled False
Interval 250

Your form should look something like this:

Page 28 of 50

Consider the following facts about the Timer control:

It is not visible to the user at run-time

The actions that you want to happen at the specified interval are coded in the
Timer's Timer event.

You specify the interval that you want actions to occur in the Timer
control's Interval property. The value is specified in milliseconds (1000 milliseconds = 1
second). In the example, the value of 250 will cause the Timer event to fire every quarter of a
second.

You turn the timer "on" or "off" by setting its Enabled property to True or False,
respectively. The Enabled property is set to True by default.

Place the following declaration in the Form's General Declarations section:


Private mintCount As Integer

Code the Click event for the two command buttons and the Timer event for the timer control as
follows:
Private Sub cmdStart_Click()

mintCount = 0
Cls
Page 29 of 50

tmrTest.Enabled = True

End Sub

Private Sub cmdStop_Click()

tmrTest.Enabled = False

End Sub

Private Sub tmrTest_Timer()

mintCount = mintCount + 1
Print "Timer fired again. Count = " & mintCount
End Sub

Run the program. Click the "Start Timer" button. Messages will appear on the form every quarter of
a second. They will stop when you click the "Stop Timer" button. A sample run might look like this:

Page 30 of 50

Download the VB project code for the example above here.

Timer Example 2

The Timer control can be used to make an object on your screen appear to blink. This is done by toggling
the Visible property of the object on and off at short intervals. The Visible property is available to nearly all
controls it is a Boolean property that determines whether or not the control is visible to the user at run
time by setting its value to True or False (it will always be visible at design time). To build a simple demo,
perform the following steps.

Start a new VB project.


Place a label on the form and name it lblProcessing. Set its Caption to Processing . . . Please Wait.
Set it to a large font and set its Forecolor property to the color of your choice. Center it on your form.
Place a timer on the form and name it tmrBlink. Set its Interval property to 250.
In the tmrBlink_Timer event, place the following single line of code:
lblProcessing.Visible = Not lblProcessing.Visible

Run the project. The label will blink. After an appropriate period of observation, close the form.

And now on to the Splash Screen example. The idea behind the splash screen example is to introduce the
user to the application by showing a form with perhaps a logo or colorful graphic. The splash screen should
display for a few seconds and then automatically switch to the application's main screen with no intervention
from the user.

To build this sample application, perform the following steps:


Start a new VB project.
Set the following properties of the form:
Property Value
(Name) frmSplash
BorderStyle 0 None

Place an Image control on the form. (Be sure to use an Image, and not a PictureBox.)
While the PictureBox is a versatile control, more overhead is involved in using it. If all you want to
do is display an image, then use the Image control. The PictureBox can also be used to display an
Page 31 of 50

image, but it also enables you to use graphics methods and can also serve as container (similar to a
Frame) that lets you house other controls. Since we don't want to do any of that stuff and just want to
display an image, we'll stick with the Image control.
Resize the Image control to encompass the size of the form. Name the control imgClouds.
Set the Stretch property to True. When the Stretch property is True, the picture you assign to the
Image control will automatically expand or contract to conform to the size of the control. When the
Stretch property is False, the Image control will automatically resize itself to expand or contract to
the size of the picture that is assigned to it.
Set the Picture property. When you click the ellipsis button on the Picture property, a dialog box will
open to allow you to navigate your system to find a suitable picture file. The main types of files that
can be assigned to an Image control are .bmp, .jpg, .ico, and .wmf. Depending on the OS you are
using, the clouds.bmp file may or may not be present on your system. If it is, the most likely place it
would be is in either the Windows or WINNT directory. If you cannot find "clouds.bmp", simply
navigate your system to locate any file of the appropriate type. Once you find your file, click Open
on the dialog box. The picture will then fill the Image control.

Place a Label on the form, move it to the center of the form and increase its width to encompass the
width of the form. Set the properties of the label as follows:
Property Value
Alignment 2 - Center
BackStyle 0 Transparent
Caption My Cool Application
Font Arial (Bold Italic, Size 24)

Place a Timer on the form and set its properties as follows:


Property Value
(Name) tmrSplash
Enabled True (the default)
Interval 3000 (3 seconds)
At this point, your form should look something like this:

Page 32 of 50

From the VB Project menu, choose Add Form and select the option to add a new form. Name the
new form frmMain. For the purpose of this demo, you need not place any controls on this form.
Back on frmSplash, code the tmrSplash_Timer event as follows:
Private Sub tmrSplash_Timer()
tmrSplash.Enabled = False
frmMain.Show
Unload Me
End Sub

Run the project. The splash screen will display for three seconds and then the main form will be
displayed. Close frmMain.
The Image Control
You've already seen in the previous topic that with an Image control, you can set it's Picture property at
design time by going to Picture property, clicking the ellipsis (), and selecting a file from the Load Picture
dialog box. Recall that the main types of files that can be assigned to an Image control
are .bmp,.jpg, .ico, and .wmf.
The Image control has a Stretch property, which is set to False by default. When the Stretch property is
False, the Image control will automatically resize itself to expand or contract to the size of the picture that is
assigned to it. If instead you want the image to fill the specific size that you make the Image control, set the
the Stretch property to True, which will cause the picture you assign to the Image control to automatically
expand or contract to conform to the size of the control. Depending on the type of image, the image may or
may not appear distorted when stretched this is something you need to experiment with.
Page 33 of 50

You can also set the Picture property of an image control in code by using the LoadPicture function, which
loads a picture from a file into the control at run-time. The LoadPicture function takes a file name as an
argument. Sample syntax is:
imgMyPic.Picture = LoadPicture("C:\SomeDirectory\SomeSubDir\MyPic.bmp")
"Picture" is the default property of the image control, so the above statement could have been written as:
imgMyPic = LoadPicture("C:\SomeDirectory\SomeSubDir\MyPic.bmp")
(Note: In my earlier VB programming, I would typically omit the default property of controls; however, I
now advocate explicitly coding all properties so I recommend keeping the ".Picture" on there.)
Keep in mind the following general points about setting the Picture property of a control using LoadPicture
at run-time compared to selecting a file for the control's Picture property at design-time:

When you set the picture at design-time, that picture becomes embedded in your application (it is
stored in the .frx file of the form that is using it). Therefore, your program is bigger, but runs faster because
the picture is in memory when your program loads.
When you use LoadPicture, the program is smaller because the image is not embedded in the
application, but resides in a separate file. However, the image processing is slower because the program
must access it from disk.
To clear the picture from an image control, use the LoadPicture function with an empty set of parentheses:
imgMyPic.Picture = LoadPicture()
If you have more than one image control on a form, you can copy a picture from one image to another via an
assignment statement like this:
imgPic1.Picture = imgPic2.Picture
- or imgPic1 = imgPic2
A common technique to change an image on a form at various points in the program is to use a number of
image controls as a "repository". The images in the "repository" will all have their Visible property set
to False. At the desired time, the program will assign one of the images from the "repository" to the image to
be displayed. The following sample program demonstrates this technique.

The sample program displays a traffic light that alternates color from green to yellow to red every half of a
second. All images used are icons from the folder:
Program Files\Microsoft Visual Studio\Common\Graphics\Icons\Traffic.

Page 34 of 50

To build the sample program, use the figure below as a guide to place the indicated controls on the default
form and set the properties of the controls to the values indicated in the callouts.

The code for the program is as follows:

Option Explicit

Private mstrCurrColor As String

Private Sub Form_Load()


mstrCurrColor = "G"
imgLight.Picture = imgGreenLight.Picture
End Sub

Private Sub tmrChangeLight_Timer()

If mstrCurrColor = "G" Then


imgLight.Picture = imgYellowLight.Picture
mstrCurrColor = "Y"
Page 35 of 50

ElseIf mstrCurrColor = "Y" Then


imgLight.Picture = imgRedLight.Picture
mstrCurrColor = "R"
Else
imgLight.Picture = imgGreenLight.Picture
mstrCurrColor = "G"
End If

End Sub

When the program runs, the traffic light will alternate in color between green, yellow, and red at intervals of
one half of a second:

Download the VB project code for the example above here.

The PictureBox Control


Like the Image control, the PictureBox control can be used to display images. However, the PictureBox can
do much more. Like the Frame control, the PictureBox is a "container" control, meaning that other controls
can be placed inside it. In addition, the PictureBox can be used to generate run-time graphics and to display
text. As a general rule of thumb, if your application requires the special capabilities of the "heavyweight"
PictureBox, then use it; but if all you want to do is display an image, then use the "lightweight" Image
control.
Using Images with the Form
Page 36 of 50

The Form has both a Picture property and an Icon property. The Form's Picture property is used to display
an image directly on the form; this can be suitable for displaying a background image. In the screen shot
below, the Form's Picture property was set to a file called "Santa Fe Stucco.bmp". The image is displayed
starting in the upper left-hand corner of the form and cannot be moved or resized. If you want to display an
image directly on the form like this, and you want the image to fill the entire background of the form, you
must make sure the image to be used is the same size or larger than the size you want to make the form. (If
the image you want for the background of the form is too small, use an Image control that you set to be the
same size as the form with its Stretch property set to True, as was done in the previous topic's sample
program with the "clouds.bmp" image.)

Note: To clear the Picture property at design-time, highlight the entry for the Picture property ("(Bitmap)" in
this case), and press the Delete key.

Page 37 of 50

The Form's Icon property is used to set the icon that is displayed in the left-hand corner of the Form's title
bar. In the screen shot below, the Form's Icon property was set to the SUN.ICO icon from the Program
Files\Microsoft Visual Studio\Common\Graphics\Icons\Elementsfolder.

When you compile a VB program, the icon used for the resulting EXE is determined by the setting of the
Icon property of the Form you specify on the "Make" tab of the project's properties sheet (accessed from the
IDE's Project menu item). As shown below, the icon that will be used for this application's EXE will be the
"sun" icon from "Form1". If the project had more than one form, then you could choose which form's icon
would be used for the EXE by selecting the appropriate form name from the "Icon:" drop-down box:

Page 38 of 50

The Picture Property of the Command Button

The Command Button control has a Style property, which, when set to 1Graphical, enables you to
display a picture on the button via the command button's Picture property. (Also when the Style is set to
1-Graphical, you can change the BackColor of the button, which you cannot do when the Style is set to 0Standard.)

If the command button also has a non-blank value for its Caption property, the text of the caption will appear
below the picture. (Note: In VB6, you cannot specify the position (left, right, below) of the picture relative
to the caption on the command button: the picture will always appear above the caption. A custom button
control would be needed to display the picture to the left or right of the caption on the button.)

The screen shot below shows two command buttons with images (the images shown are from a custom icon
set):

Page 39 of 50

The command button also has a DisabledPicture property, which allows you to specify an alternative image
to be displayed on the button when the Enabled property is set to False:

If you don't use the DisabledPicture property, the system will "do its best" to render a disabled image based
on the original what it comes up with may or may not be acceptable to you:

Another technique used with "picture buttons" is to place only a picture on the button and leave the Caption
blank then use an adjacent Label control to describe the function of the button, as shown in the
"switchboard" type screen below:

Page 40 of 50

Using Images with Other Controls

Images can be used with many with other controls. In later topics, a set of controls called the Windows
Common Controls will be explored. This set of controls comprises
the ToolBar, TreeView, ListView, TabStrip, StatusBar, and several others. These controls are used in
conjunction with an ImageList control, which serves as a repository for images to be used for items within
the controls (i.e. icons for the Toolbar buttons, TreeView nodes, ListView list items, etc.) The screen shot
below shows a portion of a screen used by an application that uses a ToolBar, TreeView, and ListView.

Page 41 of 50

Finding Images to Use with Your Applications

Probably the most challenging aspect of incorporating images (particularly icons) into your application is
not the actual programming, but simply the search for the "right" icon or image to represent the function or
concept to be worked with in your application's user interface.

As mentioned previously, Visual Studio 6/Visual Basic 6 comes with a set of over 900 graphic files (over
500 of which are icons). When Visual Studio 6 or VB 6 is installed, the Graphics folder is NOT installed by
default (whoever is installing it must explicitly check the "Graphics" option during the appropriate step of
the installation). Assuming that the Graphics are installed, by default they will be placed in the directory
structure shown below:

Page 42 of 50

The Icons folder contains 13 subfolders. As a reference, and for convenience, screen shots of the contents of
the icon folders are shown below:

Page 43 of 50

Page 44 of 50

Page 45 of 50

Page 46 of 50

Page 47 of 50

Page 48 of 50

Even with all of the icons and other graphic files included with VB, you may not find images that you deem
suitable for your application. Not all "categories" of icons that you might expect are present in the included
collections, and those that are included would be regarded by some as "dated" (the offering of included icons
has not changed since VB 3.0 back in 1995). Fortunately, there are numerous resources on the Internet for
icon collections (ranging in price from free to several hundred dollars) as well as resources for working with
icons (creating your own and/or modifying existing icons).

Page 49 of 50

Page 50 of 50

You might also like