Professional Documents
Culture Documents
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
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.
No spacing is allowed
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
Long
Single
Page 2 of 50
String
A collection of letters such as "Hello". This is used to store words and sentences.
The most basic form of loop in Visual Basic is the Do-Loop. Its construct is very simple:
Do
(Code to execute)
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
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 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
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:
Unload Me
End Sub
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.
The following code will center a form on the screen. It is best placed in the Form_Load event.
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:
With pobjForm
.Top = (Screen.Height .Height) / 2
Page 18 of 50
End Sub
With the above Sub in place, any form in the project can center itself with the following line of code:
CenterForm Me
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:
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
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:
You can then use this switch in the Activate event as follows:
' 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.
(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.
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:
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.
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.
Procedure Name
CenterForm
Description
Centers a form on the screen. This Sub has been used in previous examples presented
site.
(where FormName is the name of the form without quotes (e.g. Form1) or the keywo
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.
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).
Page 23 of 50
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.
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
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)
'=============================================================================
' Form-related Routines
'=============================================================================
With pobjForm
.Top = (Screen.Height - .Height) / 2
.Left = (Screen.Width - .Width) / 2
End With
End Sub
Page 25 of 50
End Function
' 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
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
Page 28 of 50
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.
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
tmrTest.Enabled = False
End Sub
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
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.
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.
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)
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.
Option Explicit
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:
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 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
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
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