Getting Started with Visual Basic 6.

0
Visual Basic is initiated by using the Programs option > Microsoft Visual Basic 6.0 > Visual Basic 6.0.
Clicking the Visual Basic icon, we can view a copyright screen enlisting the details of the license holder of
the copy of Visual Basic 6.0. Then it opens in to a new screen as shown in figure 1 below, with the
interface elements Such as MenuBar, ToolBar, The New Project dialog box. These elements permit the
user to buid different types of Visual Basic applications.
The Integrated Development Environment
One of the most significant changes in Visual Basic 6.0 is the Integrated Development Environment (IDE).
IDE is a term commonly used in the programming world to describe the interface and environment that we
use to create our applications. It is called integrated because we can access virtually all of the
development tools that we need from one screen called an interface. The IDE is also commonly referred
to as the design environment, or the program.
Tha Visual Basic IDE is made up of a number of components
• Menu Bar
• Tool Bar
• Project Explorer
• Properties window
• Form Layout Window
• Toolbox
• Form Designer
• Object Browser
In previous versions of Visual Basic, the IDE was designed as a Single Document Interface (SDI). In a
Single Document Interface, each window is a free-floating window that is contained within a main window
and can move anywhere on the screen as long as Visual Basic is the current application. But, in Visual
Basic 6.0, the IDE is in a Multiple Document Interface (MDI) format. In this format, the windows
associated with the project will stay within a single container known as the parent. Code and form-based
windows will stay within the main container form.
Figure 1 The Visual Basic startup dialog box

Menu Bar
This Menu Bar displays the commands that are required to build an application. The main menu items
have sub menu items that can be chosen when needed. The toolbars in the menu bar provide quick
access to the commonly used commands and a button in the toolbar is clicked once to carry out the
action represented by it.
Toolbox
The Toolbox contains a set of controls that are used to place on a Form at design time thereby creating
the user interface area. Additional controls can be included in the toolbox by using the Components menu
item on the Project menu. A Toolbox is represented in figure 2 shown below.
Figure 2 Toolbox window with its controls available commonly.

Control Description
Pointer Provides a way to move and resize the controls form
Displays icons/bitmaps and metafiles. It displays text or acts as a visual
PictureBox
container for other controls.
TextBox Used to display message and enter text.
Frame Serves as a visual and functional container for controls
CommandButton Used to carry out the specified action when the user chooses it.
CheckBox Displays a True/False or Yes/No option.
OptionButton control which is a part of an option group allows the user to
OptionButton
select only one option even it displays mulitiple choices.
ListBox Displays a list of items from which a user can select one.
Contains a TextBox and a ListBox. This allows the user to select an ietm
ComboBox
from the dropdown ListBox, or to type in a selection in the TextBox.
HScrollBar and These controls allow the user to select a value within the specified range
VScrollBar of values
Timer Executes the timer events at specified intervals of time
DriveListBox Displays the valid disk drives and allows the user to select one of them.
DirListBox Allows the user to select the directories and paths, which are displayed.
FileListBox Displays a set of files from which a user can select the desired one.
Shape Used to add shape (rectangle, square or circle) to a Form
Line Used to draw straight line to the Form
used to display images such as icons, bitmaps and metafiles. But less
Image
capability than the PictureBox
Enables the use to connect to an existing database and display information
Data
from it.
Used to link or embed an object, display and manipulate data from other
OLE
windows based applications.
Label Displays a text that the user cannot modify or interact with.

Project Explorer
Docked on the right side of the screen, just under the tollbar, is the Project Explorer window. The Project
Explorer as shown in in figure servres as a quick reference to the various elements of a project namely
form, classes and modules. All of the object that make up the application are packed in a project. A
simple project will typically contain one form, which is a window that is designed as part of a program's
interface. It is possible to develop any number of forms for use in a program, although a program may
consist of a single form. In addition to forms, the Project Explorer window also lists code modules and
classes.
Figure 3 Project Explorer

Properties Window
The Properties Window is docked under the Project Explorer window. The Properties Window exposes
the various characteristics of selected objects. Each and every form in an application is considered an
object. Now, each object in Visual Basic has characteristics such as color and size. Other characteristics
affect not just the appearance of the object but the way it behaves too. All these characteristics of an
object are called its properties. Thus, a form has properties and any controls placed on it will have
propeties too. All of these properties are displayed in the Properties Window.
Object Browser
The Object Browser allows us to browse through the various properties, events and methods that are
made available to us. It is accessed by selecting Object Browser from the View menu or pressing the key
F2. The left column of the Object Browser lists the objects and classes that are available in the projects
that are opened and the controls that have been referenced in them. It is possible for us to scroll through
the list and select the object or class that we wish to inspect. After an object is picked up from the Classes
list, we can see its members (properties, methods and events) in the right column.
A property is represented by a small icon that has a hand holding a piece of paper. Methods are denoted
by little green blocks, while events are denoted by yellow lightning bolt icon.
Object naming conversions of controls (prefix)
Form -frm
Label-lbl
TextBox-txt
CommandButton-cmd
CheckBox -chk
OptionButton -opt
ComboBox -cbo
ListBox-lst
Frame-fme
PictureBox -pic
Image-img
Shape-shp
Line -lin
HScrollBar -hsb
VScrollBar –vsb

Visual Basic 6 (VB6) Data Types, Modules and Operators

Visual Basic uses building blocks such as Variables, Data Types, Procedures, Functions and Control
Structures in its programming environment. This section concentrates on the programming fundamentals of
Visual Basic with the blocks specified.
Modules
Code in Visual Basic is stored in the form of modules. The three kind of modules are Form Modules,
Standard Modules and Class Modules. A simple application may contain a single Form, and the code
resides in that Form module itself. As the application grows, additional Forms are added and there may
be a common code to be executed in several Forms. To avoid the duplication of code, a separate module
containing a procedure is created that implements the common code. This is a standard Module.
Class module (.CLS filename extension) are the foundation of the object oriented programming in Visual
Basic. New objects can be created by writing code in class modules. Each module can contain:
Declarations : May include constant, type, variable and DLL procedure declarations.
Procedures : A sub function, or property procedure that contain pieces of code that can be executed as a
unit.
These are the rules to follow when naming elements in VB - variables, constants, controls, procedures,
and so on:
• A name must begin with a letter.
• May be as much as 255 characters long (but don't forget that somebody has to type the stuff!).
• Must not contain a space or an embedded period or type-declaration characters used to specify a
data type; these are ! # % $ & @
• Must not be a reserved word (that is part of the code, like Option, for example)
• The dash, although legal, should be avoided because it may be confused with the minus sign.
Instead of First-name use First_name or FirstName.
Data types in Visual Basic 6
By default Visual Basic variables are of variant data types. The variant data type can store numeric,
date/time or string data. When a variable is declared, a data type is supplied for it that determines the kind
of data they can store. The fundamental data types in Visual Basic including variant are integer, long,
single, double, string, currency, byte and boolean. Visual Basic supports a vast array of data types. Each
data type has limits to the kind of information and the minimum and maximum values it can hold. In
addition, some types can interchange with some other types. A list of Visual Basic's simple data types are
given below.
1. Numeric
Byte Store integer values in the range of 0 - 255
Integer Store integer values in the range of (-32,768) - (+ 32,767)
Long Store integer values in the range of (- 2,147,483,468) - (+ 2,147,483,468)
Single Store floating point value in the range of (-3.4x10-38) - (+ 3.4x1038)
Double Store large floating value which exceeding the single data type value
store monetary values. It supports 4 digits to the right of decimal point and 15
Currency
digits to the left
2. String
Use to store alphanumeric values. A variable length string can store approximately 4 billion characters
3. Date
Use to store date and time values. A variable declared as date type can store both date and time values
and it can store date values 01/01/0100 up to 12/31/9999
4. Boolean
Boolean data types hold either a true or false value. These are not stored as numeric values and cannot
be used as such. Values are internally stored as -1 (True) and 0 (False) and any non-zero value is
considered as true.
5. Variant
Stores any type of data and is the default Visual Basic data type. In Visual Basic if we declare a variable
without any data type by default the data type is assigned as default.
Operators in Visual Basic
Arithmetical Operators

Operators Description Example Result

+ Add 5+5 10
- Substract 10-5 5
/ Divide 25/5 5
\ Integer Division 20\3 6
* Multiply 5*4 20
^ Exponent (power of) 3^3 27
Mod Remainder of division 20 Mod 6 2
& String concatenation "George"&" "&"Bush" "George Bush"

Relational Operators

Operators Description Example Result

> Greater than 10>8 True
< Less than 10<8 False
>= Greater than or equal to 20>=10 True
 <= Less than or equal to 10<=20 True
<> Not Equal to 5<>4 True
= Equal to 5=7 False

Logical Operators

Operators Description
OR Operation will be true if either of the operands is true
AND Operation will be true only if both the operands are true

Variables in Visual Basic 6

Variables are the memory locations which are used to store values temporarily. A defined naming
strategy has to be followed while naming a variable. A variable name must begin with an alphabet letter
and should not exceed 255 characters. It must be unique within the same scope. It should not contain any
special character like %, &, !, #, @ or $.

There are many ways of declaring variables in Visual Basic. Depending on where the variables are
declared and how they are declared, we can determine how they can be used by our application. The
different ways of declaring variables in Visual Basic are listed below and elucidated in this section.
• Explicit Declaration
• Using Option Explicit statement
• Scope of Variables
Explicit Declaration
Declaring a variable tells Visual Basic to reserve space in memory. It is not must that a variable should be
declared before using it. Automatically whenever Visual Basic encounters a new variable, it assigns the
default variable type and value. This is called implicit declaration. Though this type of declaration is easier
for the user, to have more control over the variables, it is advisable to declare them explicitly. The
variables are declared with a Dim statement to name the variable and its type. The As type clause in the
Dim statement allows to define the data type or object type of the variable. This is called explicit
declaration.
Syntax
Dim variable [As Type]
For example,
Dim strName As String
Dim intCounter As Integer

Using Option Explicit statement

It may be convenient to declare variables implicitly, but it can lead to errors that may not be recognized at
run time. Say, for example a variable by name intcount is used implicitly and is assigned to a value. In the
next step, this field is incremented by 1 by the following statement
Intcount = intcont + 1
This calculation will result in intcount yielding a value of 1 as intcount would have been initialized to zero.
This is because the intcount variable has been mityped as incont in the right hand side of the second
 variable. But Visual Basic does not see this as a mistake and considers it to be new variable and
therefore gives a wrong result.
In Visual Basic, to prevent errors of this nature, we can declare a variable by adding the following
statement to the general declaration section of the Form.
Option Explicit
This forces the user to declare all the variables. The Option Explicit statement checks in the module for
usage of any undeclared variables and reports an error to the user. The user can thus rectify the error on
seeing this error message.
The Option Explicit statement can be explicitly placed in the general declaration section of each module
using the following steps.
• Click Options item in the Tools menu
• Click the Editor tab in the Options dialog box
• Check Require Variable Declaration option and then click the OK button

Scope of variables
A variable is scoped to a procedure-level (local) or module-level variable depending on how it is declared.
The scope of a variable, procedure or object determines which part of the code in our application are
aware of the variable's existence. A variable is declared in general declaration section of e Form, and
hence is available to all the procedures. Local variables are recognized only in the procedure in which
they are declared. They can be declared with Dim and Static keywords. If we want a variable to be
available to all of the procedures within the same module, or to all the procedures in an application, a
variable is declared with broader scope.

Local Variables
A local variable is one that is declared inside a procedure. This variable is only available to the code
inside the procedure and can be declared using the Dim statements as given below.
Dim sum As Integer
The local variables exist as long as the procedure in which they are declared, is executing. Once a
procedure is executed, the values of its local variables are lost and the memory used by these variables is
freed and can be reclaimed. Variables that are declared with keyword Dim exist only as long as the
procedure is being executed.

Static Variables
Static variables are not reinitialized each time Visual Invokes a procedure and therefore retains or
preserves value even when a procedure ends. In case we need to keep track of the number of times a
command button in an application is clicked, a static counter variable has to be declared. These static
variables are also ideal for making controls alternately visible or invisible. A static variable is declared as
given below.
Static intPermanent As Integer
Variables have a lifetime in addition to scope. The values in a module-level and public variables are
preserved for the lifetime of an application whereas local variables declared with Dim exist only while the
procedure in which they are declared is still being executed. The value of a local variable can be
preserved using the Static keyword. The follwoing procedure calculates the running total by adding new
values to the previous values stored in the static variable value.
Function RunningTotal ( )
Static Accumulate
Accumulate = Accumulate + num
RunningTotal = Accumulate
End Function
If the variable Accumulate was declared with Dim instead of static, the previously accumulated values
would not be preserved accross calls to the procedure, and the procedure would return the same value
with which it was called. To make all variables in a procedure static, the Static keyword is placed at the
beginning of the procedure heading as given in the below statement.
Static Function RunningTotal ( )
Example
The following is an example of an event procedure for a CommandButton that counts and displays the
number of clicks made.
Private Sub Command1_Click ( )
Static Counter As Integer
Counter = Counter = 1
Print Counter
End Sub
The first time we click the CommandButton, the Counter starts with its default value of zero. Visual Basic
then adds 1 to it and prints the result.

Module Levele Variables

A module level variable is available to all the procedures in the module. They are declared using the
Public or the Private keyword. If you declare a variable using a Private or a Dim statement in the
declaration section of a module—a standard BAS module, a form module, a class module, and so on—
you're creating a private module-level variable. Such variables are visible only from within the module
they belong to and can't be accessed from the outside. In general, these variables are useful for sharing
data among procedures in the same module:
' In the declarative section of any module
Private LoginTime As Date ' A private module-level variable
Dim LoginPassword As String ' Another private module-level variable
You can also use the Public attribute for module-level variables, for all module types except BAS
modules. (Public variables in BAS modules are global variables.) In this case, you're creating a strange
beast: a Public module-level variable that can be accessed by all procedures in the module to share data
and that also can be accessed from outside the module. In this case, however, it's more appropriate to
describe such a variable as a property:
' In the declarative section of Form1 module
Public CustomerName As String ' A Public property
You can access a module property as a regular variable from inside the module and as a custom property
from the outside:
' From outside Form1 module...
Form1.CustomerName = "John Smith"
The lifetime of a module-level variable coincides with the lifetime of the module itself. Private variables in
standard BAS modules live for the entire life of the application, even if they can be accessed only while
Visual Basic is executing code in that module. Variables in form and class modules exist only when that
module is loaded in memory. In other words, while a form is active (but not necessarily visible to the user)
all its variables take some memory, and this memory is released only when the form is completely
unloaded from memory. The next time the form is re-created, Visual Basic reallocates memory for all
variables and resets them to their default values (0 for numeric values, "" for strings, Nothing for object
variables).

Public vs Local Variables

A variable can have the same name and different scope. For example, we can have a public variable
named R and within a procedure we can declare a local variable R. References to the name R within the
procedure would access the local variable and references to R outside the procedure would access the
public variable.
Procedures in Visual Basic 6
Visual Basic offers different types of procedures to execute small sections of coding in applications. The
various procedures are elucidated in details in this section. Visual Basic programs can be broken into
smaller logical components called Procedures. Procedures are useful for condensing repeated operations
such as the frequently used calculations, text and control manipulation etc. The benefits of using
procedures in programming are:
It is easier to debug a program a program with procedures, which breaks a program into discrete logical
limits.
Procedures used in one program can act as building blocks for other programs with slight modifications.
A Procedure can be Sub, Function or Property Procedure.
Sub Procedures
A sub procedure can be placed in standard, class and form modules. Each time the procedure is called,
the statements between Sub and End Sub are executed. The syntax for a sub procedure is as follows:
[Private | Public] [Static] Sub Procedurename [( arglist)]
[ statements]
End Sub
arglist is a list of argument names separated by commas. Each argument acts like a variable in the
procedure. There are two types of Sub Procedures namely general procedures and event procedures.
Event Procedures
An event procedure is a procedure block that contains the control's actual name, an underscore(_), and
the event name. The following syntax represents the event procedure for a Form_Load event.
Private Sub Form_Load()
....statement block..
End Sub
Event Procedures acquire the declarations as Private by default.
General Procedures
A general procedure is declared when several event procedures perform the same actions. It is a good
programming practice to write common statements in a separate procedure (general procedure) and then
call them in the event procedure.
In order to add General procedure:
• The Code window is opened for the module to which the procedure is to be added.
• The Add Procedure option is chosen from the Tools menu, which opens an Add Procedure dialog
box as shown in the figure given below.
• The name of the procedure is typed in the Name textbox
• Under Type, Sub is selected to create a Sub procedure, Function to create a Function procedure
or Property to create a Property procedure.
• Under Scope, Public is selected to create a procedure that can be invoked outside the module, or
Private to create a procedure that can be invoked only from within the module.
We can also create a new procedure in the current module by typing Sub ProcedureName, Function
ProcedureName, or Property ProcedureName in the Code window. A Function procedure returns a value
and a Sub Procedure does not return a value.
Function Procedures
Functions are like sub procedures, except they return a value to the calling procedure. They are
especially useful for taking one or more pieces of data, called arguments and performing some tasks with
them. Then the functions returns a value that indicates the results of the tasks complete within the
function.
The following function procedure calculates the third side or hypotenuse of a right triangle, where A and B
are the other two sides. It takes two arguments A and B (of data type Double) and finally returns the
results.
Function Hypotenuse (A As Double, B As Double) As Double
Hypotenuse = sqr (A^2 + B^2)
End Function
The above function procedure is written in the general declarations section of the Code window. A
function can also be written by selecting the Add Procedure dialog box from the Tools menu and by
choosing the required scope and type.
Property Procedures
A property procedure is used to create and manipulate custom properties. It is used to create read only
properties for Forms, Standard modules and Class modules.Visual Basic provides three kind of property
procedures-Property Let procedure that sets the value of a property, Property Get procedure that returns
the value of a property, and Property Set procedure that sets the references to an object

Control Structures in Visual Basic 6.0

Control Statements are used to control the flow of program's execution. Visual Basic supports control
structures such as if... Then, if...Then ...Else, Select...Case, and Loop structures such as Do While...Loop,
While...Wend, For...Next etc method.
If...Then selection structure
The If...Then selection structure performs an indicated action only when the condition is True; otherwise
the action is skipped.
Syntax of the If...Then selection
If <condition> Then
statement
End If
e.g.: If average>75 Then
txtGrade.Text = "A"
End If

If...Then...Else selection structure

The If...Then...Else selection structure allows the programmer to specify that a different action is
to be performed when the condition is True than when the condition is False.
Syntax of the If...Then...Else selection
If <condition > Then
statements
Else
statements
End If
e.g.: If average>50 Then
txtGrade.Text = "Pass"
Else
txtGrade.Text = "Fail"
End If

Nested If...Then...Else selection structure

Nested If...Then...Else selection structures test for multiple cases by placing
If...Then...Else selection structures inside If...Then...Else structures.
Syntax of the Nested If...Then...Else selection structure
You can use Nested If either of the methods as shown above
Method 1
If < condition 1 > Then
statements
ElseIf < condition 2 > Then
statements
ElseIf < condition 3 > Then
statements
Else
Statements
End If
Method 2
If < condition 1 > Then
statements
Else
If < condition 2 > Then
statements
Else
If < condition 3 > Then
statements
Else
Statements
End If
End If
EndIf
e.g.: Assume you have to find the grade using nested if and display in a text box
If average > 75 Then
txtGrade.Text = "A"
ElseIf average > 65 Then
txtGrade.Text = "B"
ElseIf average > 55 Then
txtGrade.text = "C"
ElseIf average > 45 Then
txtGrade.Text = "S"
Else
txtGrade.Text = "F"
End If

Select...Case selection structure

Select...Case structure is an alternative to If...Then...ElseIf for selectively executing a
single block of statements from among multiple block of statements. Select...case is more
convenient to use than the If...Else...End If. The following program block illustrate the working
of Select...Case.
Syntax of the Select...Case selection structure
Select Case Index
Case 0
Statements
Case 1
Statements
End Select

e.g.: Assume you have to find the grade using select...case and display in the text box
Dim average as Integer

average = txtAverage.Text
Select Case average
Case 100 To 75
txtGrade.Text ="A"
Case 74 To 65
txtGrade.Text ="B"
Case 64 To 55
txtGrade.Text ="C"
Case 54 To 45
txtGrade.Text ="S"
Case 44 To 0
txtGrade.Text ="F"
Case Else
MsgBox "Invalid average marks"
End Select

Repetition Structures in Visual Basic

A repetition structure allows the programmer to that an action is to be repeated until given condition is
true.
Do While... Loop Statement
The Do While...Loop is used to execute statements until a certain condition is met. The following Do
Loop counts from 1 to 100.
Dim number As Integer
number = 1
Do While number <= 100
number = number + 1
Loop
A variable number is initialized to 1 and then the Do While Loop starts. First, the condition is tested; if
condition is True, then the statements are executed. When it gets to the Loop it goes back to the Do and
tests condition again. If condition is False on the first pass, the statements are never executed.
While... Wend Statement
A While...Wend statement behaves like the Do While...Loop statement. The following While...Wend
counts from 1 to 100
Dim number As Integer

number = 1
While number <=100
number = number + 1
Wend

Do...Loop While Statement

The Do...Loop While statement first executes the statements and then test the condition after each
execution. The following program block illustrates the structure:
Dim number As Long
number = 0
Do
number = number + 1
Loop While number < 201
The programs executes the statements between Do and Loop While structure in any case. Then it
determines whether the counter is less than 501. If so, the program again executes the statements
between Do and Loop While else exits the Loop.
Do Until...Loop Statement
Unlike the Do While...Loop and While...Wend repetition structures, the Do Until... Loop structure tests a
condition for falsity. Statements in the body of a Do Until...Loop are executed repeatedly as long as the
loop-continuation test evaluates to False.
An example for Do Until...Loop statement. The coding is typed inside the click event of the command
button
Dim number As Long
number=0
Do Until number > 1000
number = number + 1
Print number
Loop
Numbers between 1 to 1000 will be displayed on the form as soon as you click on the command button.
The For...Next Loop
The For...Next Loop is another way to make loops in Visual Basic. For...Next repetition structure handles
all the details of counter-controlled repetition. The following loop counts the numbers from 1 to 100:
Dim x As Integer
For x = 1 To 50
Print x
Next
In order to count the numbers from 1 yo 50 in steps of 2, the following loop can be used
For x = 1 To 50 Step 2
Print x
Next
The following loop counts numbers as 1, 3, 5, 7..etc

The above coding will display numbers vertically on the form. In order to display numbers horizontally the
following method can be used.
For x = 1 To 50
Print x & Space$ (2);
Next
To increase the space between the numbers increase the value inside the brackets after the & Space$.
Following example is a For...Next repetition structure which is with the If condition used.
Dim number As Integer
For number = 1 To 10
If number = 4 Then
Print "This is number 4"
Else
Print number
End If
Next
In the output instead of number 4 you will get the "This is number 4".

Exit For and Exit Do Statement

A For...Next loop condition can be terminated by an Exit For statement. Consider the following statement
block.
Dim x As Integer
For x = 1 To 10
Print x
If x = 5 Then
Print "The program exited at x=5"
End If
Next
The preceding code increments the value of x by 1 until it reaches the condition x = 5. The Exit For
statement is executed and it terminates the For...Next loop. The Following statement block containing
Do...While loop is terminated using Exit Do statement.
Dim x As Integer
Do While x < 10
Print x
x = x + 1
If x = 5 Then
Print "The program is exited at x=5"
Exit Do
End If
Loop

With...End With statement

When properties are set for objects or methods are called, a lot of coding is included that acts on the
same object. It is easier to read the code by implementing the With...End With statement. Multiple
properties can be set and multiple methods can be called by using the With...End With statement. The
code is executed more quickly and efficiently as the object is evaluated only once. The concept can be
clearly understood with following example.
With Text1
.Font.Size = 14
.Font.Bold = True
.ForeColor = vbRed
.Height = 230
.Text = "Hello World"
End With
In the above coding, the object Text1, which is a text box is evaluated only once instead of every
associated property or method. This makes the coding simpler and efficient.

VB Array - Arrays in Visual Basic 6

An array is a consecutive group of memory locations that all have the same name and the same type. To
refer to a particular location or element in the array, we specify the array name and the array element
position number.
The Individual elements of an array are identified using an index. Arrays have upper and lower bounds
and the elements have to lie within those bounds. Each index number in an array is allocated individual
memory space and therefore users must evade declaring arrays of larger size than required. We can
declare an array of any of the basic data types including variant, user-defined types and object variables.
The individual elements of an array are all of the same data type.
Declaring arrays
Arrays occupy space in memory. The programmer specifies the array type and the number of elements
required by the array so that the compiler may reserve the appropriate amount of memory. Arrays may be
declared as Public (in a code module), module or local. Module arrays are declared in the general
declarations using keyword Dim or Private. Local arrays are declared in a procedure using Dim or Static.
Array must be declared explicitly with keyword "As".
There are two types of arrays in Visual Basic namely:

Fixed-size array : The size of array always remains the same-size doesn't change during the program
execution.

Dynamic array : The size of the array can be changed at the run time- size changes during the
program execution.
Fixed-sized Arrays
When an upper bound is specified in the declaration, a Fixed-array is created. The upper limit should
always be within the range of long data type.
Declaring a fixed-array
Dim numbers(5) As Integer
In the above illustration, numbers is the name of the array, and the number 6 included in the parentheses
is the upper limit of the array. The above declaration creates an array with 6 elements, with index
numbers running from 0 to 5.
If we want to specify the lower limit, then the parentheses should include both the lower and upper limit
along with the To keyword. An example for this is given below.
Dim numbers (1 To 6 ) As Integer
In the above statement, an array of 10 elements is declared but with indexes running from 1 to 6.
A public array can be declared using the keyword Public instead of Dim as shown below.
Public numbers(5) As Integer

Multidimensional Arrays
Arrays can have multiple dimensions. A common use of multidimensional arrays is to represent tables of
values consisting of information arranged in rows and columns. To identify a particular table element, we
must specify two indexes: The first (by convention) identifies the element's row and the second (by
convention) identifies the element's column.
Tables or arrays that require two indexes to identify a particular element are called two dimensional
arrays. Note that multidimensional arrays can have more than two dimensions. Visual Basic supports at
least 60 array dimensions, but most people will need to use more than two or three dimensional-arrays.
The following statement declares a two-dimensional array 50 by 50 array within a procedure.
Dim AvgMarks ( 50, 50)
It is also possible to define the lower limits for one or both the dimensions as for fixed size arrays. An
example for this is given here.
Dim Marks ( 101 To 200, 1 To 100)
An example for three dimensional-array with defined lower limits is given below.
Dim Details( 101 To 200, 1 To 100, 1 To 100)

Static and dynamic arrays

Basically, you can create either static or dynamic arrays. Static arrays must include a fixed number of
items, and this number must be known at compile time so that the compiler can set aside the necessary
amount of memory. You create a static array using a Dim statement with a constant argument:
' This is a static array.
Dim Names(100) As String
Visual Basic starts indexing the array with 0. Therefore, the preceding array actually holds 101 items.
Most programs don't use static arrays because programmers rarely know at compile time how many
items you need and also because static arrays can't be resized during execution. Both these issues are
solved by dynamic arrays. You declare and create dynamic arrays in two distinct steps. In general, you
declare the array to account for its visibility (for example, at the beginning of a module if you want to make
it visible by all the procedures of the module) using a Dim command with an empty pair of brackets. Then
you create the array when you actually need it, using a ReDim statement:
' An array defined in a BAS module (with Private scope)
Dim Customers() As String
...
Sub Main()
' Here you create the array.
ReDim Customer(1000) As String
End Sub
If you're creating an array that's local to a procedure, you can do everything with a single ReDim
statement:
Sub PrintReport()
' This array is visible only to the procedure.
ReDim Customers(1000) As String
' ...
End Sub
If you don't specify the lower index of an array, Visual Basic assumes it to be 0, unless an Option Base 1
statement is placed at the beginning of the module. My suggestion is this: Never use an Option Base
statement because it makes code reuse more difficult. (You can't cut and paste routines without worrying
about the current Option Base.) If you want to explicitly use a lower index different from 0, use this syntax
instead:
ReDim Customers(1 To 1000) As String
Dynamic arrays can be re-created at will, each time with a different number of items. When you re-create
a dynamic array, its contents are reset to 0 (or to an empty string) and you lose the data it contains. If you
want to resize an array without losing its contents, use the ReDim Preserve command:
ReDim Preserve Customers(2000) As String
When you're resizing an array, you can't change the number of its dimensions nor the type of the values it
contains. Moreover, when you're using ReDim Preserve on a multidimensional array, you can resize only
its last dimension:
ReDim Cells(1 To 100, 10) As Integer
...
ReDim Preserve Cells(1 To 100, 20) As Integer ' This works.
ReDim Preserve Cells(1 To 200, 20) As Integer ' This doesn't.
Finally, you can destroy an array using the Erase statement. If the array is dynamic, Visual Basic releases
the memory allocated for its elements (and you can't read or write them any longer); if the array is static,
its elements are set to 0 or to empty strings.
You can use the LBound and UBound functions to retrieve the lower and upper indices. If the array has
two or more dimensions, you need to pass a second argument to these functions to specify the dimension
you need:
Print LBound(Cells, 1) ' Displays 1, lower index of 1st dimension
Print LBound(Cells) ' Same as above
Print UBound(Cells, 2) ' Displays 20, upper index of 2nd dimension
' Evaluate total number of elements.
NumEls = (UBound(Cells) _ LBound(Cells) + 1) * _
(UBound(Cells, 2) _ LBound(Cells, 2) + 1)

Arrays within UDTs

UDT structures can include both static and dynamic arrays. Here's a sample structure that contains both
types:
Type MyUDT
StaticArr(100) As Long
DynamicArr() As Long
End Type
...
Dim udt As MyUDT
' You must DIMension the dynamic array before using it.
ReDim udt.DynamicArr(100) As Long
' You don't have to do that with static arrays.
udt.StaticArr(1) = 1234
The memory needed by a static array is allocated within the UDT structure; for example, the StaticArr
array in the preceding code snippet takes exactly 400 bytes. Conversely, a dynamic array in a UDT takes
only 4 bytes, which form a pointer to the memory area where the actual data is stored. Dynamic arrays
are advantageous when each individual UDT variable might host a different number of array items. As
with all dynamic arrays, if you don't dimension a dynamic array within a UDT before accessing its items,
you get an error 9—"Subscript out of range."

VB6 Arrays and variants (Visual Basic 6)

Visual Basic lets you store arrays in Variant variables and then access the array items using the Variant
variable as if it were an array:
ReDim Names(100) As String, var As Variant
' Initialize the Names array (omitted).
var = Names() ' Copy the array into the Variant.
Print var(1) ' Access array items through the Variant.
You can even create an array of Variant elements on the fly using the Array function and store it in a
Variant variable:
' Arrays returned by the Array() function are zero-based.
Factorials = Array(1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800)
Likewise, you can pass an array to a procedure that expects a Variant parameter and then access the
elements of the array through that parameter:
' A polymorphic function that sums the values in any array
Function ArraySum(arr As Variant) As Variant
Dim i As Long, result As Variant
For i = LBound(arr) To UBound(arr)
result = result + arr(i)
Next
ArraySum = result
End Function
The most interesting feature of the preceding routine is that it works correctly with any type of numeric
one-dimensional array. It even works with String arrays, but in that case you get the concatenation of all
items, not their sum. This procedure is extremely powerful and reduces the amount of code you have to
write to deal with different kinds of arrays. But you should be aware that accessing array items through a
Variant parameter noticeably slows down the execution. If you need the best performance, write specific
routines that process specific types of arrays.
You can also pass a multidimensional array to a routine that expects a Variant parameter. In this case,
you can still access the array elements through the Variants, but if you don't know at compile time how
many dimensions the array has, your routine has to determine that number before proceeding. You can
get this value using a trial-and-error approach:
' This routine returns the number of dimensions of the array
' passed as an argument, or 0 if it isn't an array.
Function NumberOfDims(arr As Variant) As Integer
Dim dummy as Long
On Error Resume Next
Do
dummy = UBound(arr, NumberOfDims + 1)
If Err Then Exit Do
NumberOfDims = NumberOfDims + 1
Loop
End Function
It's perfectly legal to use the function name inside a function's code as if it were a local variable, as the
previous code snippet does. Often this technique lets you save a local variable and a final assignment
before exiting the routine, which indirectly makes your code run slightly faster.
Here's a modified ArraySum routine that uses NumberOfDims and works with both one- and two-
dimensional arrays:
Function ArraySum2(arr As Variant) As Variant
Dim i As Long, j As Long, result As Variant
' First check whether we can really work with this array.
Select Case NumberOfDims(arr)
Case 1 ' One-dimensional array
For i = LBound(arr) To UBound(arr)
result = result + arr(i)
Next
Case 2 ' Two-dimensional array
For i = LBound(arr) To UBound(arr)
For j = LBound(arr, 2) To UBound(arr, 2)
result = result + arr(i, j)
Next
Next
Case Else ' Not an array, or too many dimensions
Err.Raise 1001, , "Not an array or more than two dimensions"
End Select
ArraySum2 = result
End Function
Often, if a Variant contains an array, you don't know the basic type of that array in advance. The VarType
function returns the sum of the vbArray constant (decimal 8192), plus the VarType of the data included in
the array. This lets you test that the array passed to a routine is of a given type:
If VarType(arr) = (vbArray + vbInteger) Then
' Array of integers
ElseIf VarType(arr) = (vbArray + vbLong) Then
' Array of Longs
ElseIf VarType(arr) And vbArray Then
' An array of another type (just tests a bit)
End If
You can also test whether a Variant holds an array using the IsArray function. When a Variant variable
holds an array, the TypeName function appends a pair of empty parentheses to its result:
Print TypeName(arr) ' Displays "Integer()"
As I've explained, you can either assign an array to a Variant variable or you can pass an array as a
Variant parameter of a procedure. While the two operations look very similar, they're substantially
different. To execute an assignment, Visual Basic makes a physical copy of the array. As a result, the
Variant variable doesn't point to the original data but to the copy; from this point on, all the manipulations
you do through the Variant variable don't affect the original array. Conversely, if you call a procedure and
pass an array as a Variant parameter, no data is physically copied and the Variant simply works as an
alias of the array. You can reorder array items or modify their values, and your changes are immediately
reflected in the original array

Assigning and returning arrays in Visual Basic 6

Visual Basic 6 adds two important features to arrays. First, you can perform assignments between arrays.
Second, you can write procedures that return arrays. You can assign arrays only of the same type and
only if the target is a dynamic array. (The latter condition is necessary because Visual Basic might need
to resize the target array.)
ReDim a(10, 10) As Integer
Dim b() As Integer
' Fill the a array with data (omitted).
b() = a() ' This works!
It's no surprise that native assignment commands are always faster than the corresponding For…Next
loops that copy one item at a time. The actual increment in speed heavily depends on the data type of the
arrays and can vary from 20 percent to 10 times faster. A native assignment between arrays also works if
the source array is held in a Variant. Under Visual Basic 4 and 5, you could store an array in a Variant,
but you couldn't do the opposite—that is, retrieve an array stored in a Variant variable and store it back in
an array of a specific type. This flaw has been fixed in Visual Basic 6:
Dim v As Variant, s(100) As String, t() As String
' Fill the s() array (omitted).
v = s() ' Assign to a Variant.
t() = v ' Assign from a Variant to a dynamic string array.
You often use the capacity to assign arrays to build functions that return arrays. Notice that pair of
brackets at the end of the first line in the following procedure:
Function InitArray(first As Long, Last As Long) As Long()
ReDim result(first To Last) As Long
Dim i As Long
For i = first To Last
result(i) = i
Next
InitArray = result
End Function
The new capability of returning arrays lets you write highly versatile array routines. Visual Basic 6 itself
includes a few new string functions—namely Join, Split, and Filter—that rely on it. (You'll find more about
these new string functions in Chapter 5). Here are two examples of what you can do with this intriguing
feature:
' Returns a portion of a Long array
' Note: fails if FIRST or LAST are not valid
Function SubArray(arr() As Long, first As Long, last As Long, _
newFirstIndex As Long) As Long()
Dim i As Long
ReDim result(newFirstIndex To last _ first + newFirstIndex) As Long
For i = first To last
result(newFirstIndex + i - first) = arr(i)
Next
SubArray = result
End Function
' Returns an array with all the selected items in a ListBox
Function SelectedListItems(lst As ListBox) As String()
Dim i As Long, j As Long
ReDim result(0 To lst.SelCount) As String
For i = 0 To lst.ListCount - 1
If lst.Selected(i) Then
j = j + 1
result(j) = lst.List(i)
End If
Next
SelectedListItems = result
End Function

User-Defined Data Types

Variables of different data types when combined as a single variable to hold several related informations is
called a User-Defined data type.
A Type statement is used to define a user-defined type in the General declaration section of a form or
module. User-defined data types can only be private in form while in standard modules can be public or
private. An example for a user defined data type to hold the product details is as given below.
Private Type ProductDetails
ProdID as String
ProdName as String
Price as Currency
End Type
The user defined data type can be declared with a variable using the Dim statement as in any other
variable declaration statement. An array of these user-defined data types can also be declared. An
example to consolidate these two features is given below.
Dim ElectronicGoods as ProductDetails ' One Record
Dim ElectronicGoods(10) as ProductDetails ' An array of 11 records
A User-Defined data type can be referenced in an application by using the variable name in the procedure
along with the item name in the Type block. Say, for example if the text property of a TextBox namely
text1 is to be assigned the name of the electronic good, the statement can be written as given below.
Text1.Text = ElectronicGoods.ProdName
If the same is implemented as an array, then the statement becomes
Text1.Text = ElectronicGoods(i).ProdName
User-defined data types can also be passed to procedures to allow many related items as one argument.
Sub ProdData( ElectronicGoods as ProductDetails)
Text1.Text = ElectronicGoods.ProdName
Text1.Text = ElectronicGoods.Price
End Sub

Constants, Data Type Conversion, Visual Basic Built-in Functions

Constants
Constants are named storage locations in memory, the value of which does not change during program
Execution. They remain the same throughout the program execution. When the user wants to use a value
that never changes, a constant can be declared and created. The Const statement is used to create a
constant. Constants can be declared in local, form, module or global scope and can be public or private
as for variables. Constants can be declared as illustrated below.
Public Const gravityconstant As Single = 9.81

Predefined Visual Basic Constants

The predefined constants can be used anywhere in the code in place of the actual numeric values. This
makes the code easier to read and write.
For example consider a statement that will set the window state of a form to be maximized.
Form1.Windowstate = 2
The same task can be performed using a Visual Basic constant
Form1.WindowState = vbMaximized

Data Type Conversion

Visual Basic functions either to convert a string into an integer or vice versa and many more conversion
functions. A complete listing of all the conversion functions offered by Visual Basic is elucidated below.

Conversion To Function
Boolean Cbool
Byte Cbyte
Currency Ccur
Date Cdate
Decimals Cdec
Double CDbl
Integer Cint
Long CLng
Single CSng
String CStr
Variant Cvar
Error CVErr
A conversion function should always be placed at the right hand side of the calculation statement.
Visual Basic Built-in Functions
Many built-in functions are offered by Visual Basic fall under various categories. These functions are
procedures that return a value. The functions fall into the following basic categories that will be discussed
in the follwing sections at length.
• Date and Time Functions
• Format Function
• String Functions

Date and Time Functions in Visual Basic 6

Not only does Visual Basic let you store date and time information in the specific Date data type, it also
provides a lot of date- and time-related functions. These functions are very important in all business
applications and deserve an in-depth look. Date and Time are internally stored as numbers in Visual
Basic. The decimal points represents the time between 0:00:00 and 23:59:59 hours inclusive.
The system's current date and time can be retrieved using the Now, Date and Time functions in Visual
Basic. The Now function retrieves the date and time, while Date function retrieves only date and Time
function retrieves only the time.
To display both the date and time together a message box is displayed use the statement given below.
MsgBox "The current date and time of the system is" & Now
Here & is used as a concatenation operator to concentrate the string and the Now function. Selective
portions of the date and time value can be extracted using the below listed functions.

Function Extracted Portion

Year ( ) Year (Now)
Month ( ) Month (Now)
Day ( ) Day (Now)
WeekDay ( ) WeekDay (Now)
Hour ( ) Hour (Now)
Minute ( ) Minute (Now)
Second ( ) Second (Now)
The calculation and conversion functions related to date and time functions are listed below.

Function Description
DateAdd ( ) Returns a date to which a specific interval has been added
DateDiff ( ) Returns a Long data type value specifying the interval between the
two values
DatePart ( ) Returns an Integer containing the specified part of a given date
DateValue ( ) Converts a string to a Date
TimeValue ( ) Converts a string to a time
DateSerial ( ) Returns a date for specified year, month and day

DateDiff Function
The DateDiff function returns the intervals between two dates in terms of years, months or days. The
syntax for this is given below.
DateDiff (interval, date1, date2[, firstdayofweek[, firstweekofyear]])

Format Function
The format function accepts a numeric value and converts it to a string in the format specified by the
format argument. The syntax for this is given below.
Format (expression[, format[, firstdayofweek[, firstweekofyear]]])
The Format function syntax has these parts:

Part Description
Expression Required any valid expression
format Optional. A valid named or user-defined format expression.
firstdayofweek Optional. A contant that specifies the first day of the week.
firstweekofyear Optional. A contant that specifies the first week of the year

Getting and Setting the Current Date and Time

Strictly speaking, Date and Time aren't functions: They're properties. In fact, you can use them to either
retrieve the current date and time (as Date values) or assign new values to them to modify the system
settings:
Print Date & " " & Time ' Displays "8/14/98 8:35:48 P.M.".
' Set a new system date using any valid date format.
Date = "10/14/98"
Date = "October 14, 1998"
To help you compare the outcome of all date and time functions, all the examples in this section assume
that they're executed at the date and time shown in the preceding code snippet: October 17, 2008,
9:25:33 p.m.
The outdated Date$ and Time$ properties can also be used for the same task. They're String properties,
however, and therefore recognize only the mm/dd/yy or mm/dd/yyyy formats and the hh:mm:ss and
hh:mm formats, respectively. For this reason, it's usually better to use the new $-less functions.
The Now function returns a Date value that contains the current date and time:
Print Now ' Displays "10/17/2008 9:25:33 P.M.".
But the time-honored Timer function returns the number of seconds elapsed from midnight and is more
accurate than Now because the Timer function includes fractional parts of seconds. (The actual accuracy
depends on the system.) This function is often used for benchmarking a portion of code:
StartTime = Timer
' Insert the code to be benchmarked here.
Print Timer - StartTime
The preceding code suffers from some inaccuracy: The StartTime variable might be assigned when the
system tick is about to expire, so your routine could appear to take longer than it actually does. Here's a
slightly better approach:
StartTime = NextTimerTick
' Insert the code to be benchmarked here.
Print Timer _ StartTime
' Wait for the current timer tick to elapse.
Function NextTimerTick() As Single
Dim t As Single
t = Timer
Do: Loop While t = Timer
NextTimerTick = Timer
End Function
If you're using the Timer function in production code, you should be aware that it's reset at midnight, so
you always run the risk of introducing unlikely but potentially serious errors. Try to spot the bug in this
routine, which adds a CPU-independent pause in your code:
' WARNING: this procedure has a bug.
Sub BuggedPause(seconds As Integer)
Dim start As Single
start = Timer
Do: Loop Until Timer _ start >= seconds
End Sub
The bug manifests itself very rarely—for example, if the program asks for a 2-second pause at 11:59:59
p.m. Even if this probability is small, the effect of this minor bug is devastating and you'll have to press
Ctrl+Alt+Del to kill your compiled application. Here's a way to work around this issue:
' The correct version of the procedure
Sub Pause(seconds As Integer)
Const SECS_INDAY = 24! * 60 * 60 ' Seconds per day
Dim start As Single
start = Timer
Do: Loop Until (Timer + SECS_INDAY - start) Mod SECS_INDAY >= seconds
End Sub

Building and Extracting Date and Time Values - VB6 Date & Time
There are many ways to assemble a Date value. For example, you can use a Date constant, such as the
following:
StartDate = #10/17/2008 9:25:33 P.M.#
but more often you'll build a Date value using one of the many functions that VBA gives you. The
DateSerial function builds a Date value from its year/month/day components; similarly, the TimeSerial
function builds a Time value from its hour/minute/second components:
Print DateSerial(2008, 10, 17) ' Displays "10/17/2008"
Print TimeSerial(12, 20, 30) ' Displays "12:20:30 P.M."
' Note that they don't raise errors with invalid arguments.
Print DateSerial(2008, 4, 31) ' Displays "5/1/2008"
The DateSerial function is also useful for determining indirectly whether a particular year is a leap year:
Function IsLeapYear(year As Integer) As Boolean
' Are February 29 and March 1 different dates?
IsLeapYear = DateSerial(year, 2, 29) <> DateSerial(year, 3, 1)
End Function
The DateValue and TimeValue functions return the date or time portions of their argument, which can be
a string or a Date expression:
' The date a week from now
Print DateValue(Now + 7) ' Displays "10/17/2008"
A bunch of VBA functions let you extract date and time information from a Date expression or variable.
The Day, Month, and Year functions return date values, whereas the Hour, Minute, and Second functions
return time values:
' Get information about today's date.
y = Year(Now): m = Month(Now): d = Day(Now)
' These functions also support any valid date format.
Print Year("10/17/2008 9:25:33 P.M.") ' Displays "2008"
The Weekday function returns a number in the range 1 through 7, which corresponds to the day of the
week of a given Date argument:
Print Weekday("10/17/2008") ' Displays "6" (= vbFriday)
The Weekday function returns 1 when the date is the first day of the week. This function is locale aware,
which means that under different localizations of Microsoft Windows it could consider the first day of the
week to be different from vbSunday. In most cases, this condition doesn't affect the structure of your
code. But if you want to be sure that 1 means Sunday, 2 means Monday, and so on, you can force the
function to return a consistent value under all Windows systems, as follows:
Print Weekday(Now, vbSunday)
Although using the optional second argument forces the function to return the correct value, it doesn't
change the system localization. If you next call the Weekday function without the second argument, it will
still consider the first day of the week to be what it was before.
Finally you can extract any date and time information from a Date value or expression using the DatePart
function, for which the syntax is
Result = DatePart(Interval, Date, [FirstDayOfWeek], [FirstWeekOfYear])
You'll rarely need to resort to this function because you can do most of your calculations using the other
functions I've shown you so far. In two cases, however, this function is really useful:
' The quarter we are in
Print DatePart("q", Now) ' Displays "3"
' The week number we are in (# of weeks since Jan 1st)
Print DatePart("ww", Now) ' Displays "33"
The first argument can be one of the String constants listed in the following table. For more information
about the two optional arguments, see the description of the DateAdd function in the next section.
Possible values for the interval argument in DatePart, DateAdd, and DateDiff functions.
Setting Description
"yyyy" Year
"q" Quarter
"m" Month
"y" Day of the year (same as d)
"d" Day
"w" Weekday
"ww" Week
"h" Hour
"n" Minute
"s" Second

Date Arithmetic - VB6 Date & Time

In most cases, you don't need any special functions to perform date arithmetic. All you need to know is
that the integer part in a Date variable holds the date information, and the fractional part holds the time
information:
' 2 days and 12 hours from now
Print Now + 2 + #12:00# ' Displays "8/17/2008 8:35:48 A.M."
For more sophisticated date math, you can use the DateAdd function, for which the syntax is the
following:
NewDate = DateAdd(interval, number, date)
The interval is a string that indicates a date or time unit (see table below), number is the number of units
you are adding, and date is the starting date. You can use this function to add and subtract date and time
values:
' The date three months from now
Print DateAdd("m", 3, Now) ' Displays "11/14/2008 8:35:48 P.M."
' One year ago (automatically accounts for leap years)
Print DateAdd("yyyy", -1, Now) ' Displays "8/14/2007 8:35:48 P.M."
' The number of months since Jan 30, 2008
Print DateDiff("m", #1/30/2008#, Now) ' Displays "7"
' The number of days since Jan 30, 2008 _ you can use "d" or "y".
Print DateDiff("y", #1/30/2008#, Now) ' Displays "196"
' The number of entire weeks since Jan 30, 2008
Print DateDiff("w", #1/30/2008#, Now) ' Displays "28"
' The number of weekends before 21st century - value <0 means
' future dates.
' Note: use "ww" to return the number of Sundays in the date interval.
Print DateDiff("ww", #1/1/2000#, Now) ' Displays "-72"
When you have two dates and you want to evaluate the difference between them—that is, the time
elapsed between one date and the next—you should use the DateDiff function, for which the syntax is
Result = DateDiff(interval, startdate, enddate _
[, FirstDayOfWeek[, FirstWeekOfYear]])
where interval has the meaning shown in the previous page Building and Extracting Date and Time
Values's table, FirstDayOfWeek is an optional argument that you can use to specify which weekday
should be considered as the first day of the week (you can use the constants vbSunday, vbMonday, and
so on), and FirstWeekOfYear is another optional argument that lets you specify which week should be
considered as the first week of the year.
Possible values for the FirstWeekOfYear argument in the DateDiff function.
Constant Value Description
vbUseSystem 0 Use the NLS API setting.
vbFirstJan1 1 The first week is the one that includes January 1. (This is the
default value for this setting.)
vbFirstFourDays 2 The first week is the first one that has at least four days in the new
year.
vbFirstFullWeek 3 This first week is the first one that's completely contained in the
new year.

Working with controls in Visual Basic 6

This lesson concentrates on Visual Basic controls and the ways of creating and implementing the. It also
helps us to understand the concept of Control Arrays. Controls are used to recieve user input and display
output and has its own set of properties, methods and events. Let us discuss few of these controls in this
lesson.
Creating and Using Controls
 A control is an object that can be drawn on a Form object to enable or enhance user interaction with an
application. Controls have properties that define aspects their appearance, such as position, size and
colour, and aspects of their behavior, such as their response to the user input. They can respond to
events initiated by the user or set off by the system. For instance, a code could be written in a
CommandButton control's click event procedure that would load a file or display a result.
In addition to properties and events, methods can also be used to manipulate controls from code. For
instance, the move method can be used with some controls to change their location and size.
Most of the controls provide choices to users that can be in the form of OptionButton or CheckBox
controls, ListBox entries or ScrollBars to select a value. Let us discuss these controls by means of a few
simple applications in the following lessons.
Classification of Controls
Visual Basic cojntrols are broadly classified as standard controls, ActiveX controls and insertable objects.
Standard controls such as CommandButton, Label and Frame controls are contained inside .EXE file and
are always included in the ToolBox which cannot be removed. ActiveX controls exist as separate files with
either .VBX or .OCX extension. They include specialized controls such as;
• MSChart control
• The Communications control
• The Animation control
• The ListView control
• An ImageList control
• The Multimedia control
• The Internet Transfer control
• The WinSock control
• The TreeView control
• The SysInfo control
• The Picture Clip control
Some of these objects support OLE Automation, which allow programming another application's object
from within Visual Basic application.
I would like to stress that knowing how and when to set the objects' properties is very important as it can
help you to write a good program or you may fail to write a good program. So, I advice you to spend a lot
of time playing with the objects' properties
Here are some important points about setting up the properties
• You should set the Caption Property of a control clearly so that a user knows what to do with that
command. For example, in the calculator program, all the captions of the command buttons such as +, - ,
MC, MR are commonly found in an ordinary calculator, a user should have no problem in manipulating
the buttons.
• A lot of programmers like to use a meaningful name for the Name Property may be because it is
easier for them to write and read the event procedure and easier to debug or modify the programs later.
However, it is not a must to do that as long as you label your objects clearly and use comments in the
program whenever you feel necessary
• One more important property is whether the control is enabled or not
• Finally, you must also considering making the control visible or invisible at runtime, or when
should it become visible or invisible
TabIndex property of Controls
Visual Basic uses the TabIndex property to determine the control that would receive the focus next when
a tab key is pressed. Every time a tab key is pressed, Visual Basic looks at the value of the TabIndex for
the control that has focus and then it scans through the controls searching for the next highest TabIndex
number. When there are no more controls with higher TabIndex value, Visual Basic starts all over again
with 0 and looks for the first control with TabIndex of 0 or higher that can accept keyboard input.
By default, Visual Basic assigns a tab order to control as we draw the controls on the Form, except for
Menu, Timer, Data, Image, Line and Shape controls, which are not included in tab order. At run time,
invisible or disabled controls also cannot receive the focus although a TabIndex value is given. Setting the
TabIndex property of controls is compulsory in development environment.

Using TextBox Control In Visual Basic 6

TextBox controls offer a natural way for users to enter a value in your program. For this reason, they tend
to be the most frequently used controls in the majority of Windows applications. TextBox controls, which
have a great many properties and events, are also among the most complex intrinsic controls. In this
section, I guide you through the most useful properties of TextBox controls and show how to solve some
of the problems that you're likely to encounter.
Setting properties to a TextBox
• Text can be entered into the text box by assigning the necessary string to the text property of the
control
• If the user needs to display multiple lines of text in a TextBox, set the MultiLine property to True
• To customize the scroll bar combination on a TextBox, set the ScrollBars property.
• Scroll bars will always appear on the TextBox when it's MultiLine property is set to True and its
ScrollBars property is set to anything except None(0)
• If you set the MultilIne property to True, you can set the alignment using the Alignment property.
The test is left-justified by default. If the MultiLine property is et to False, then setting the Alignment
property has no effect.
Run-Time Properties of a TextBox control
The Text property is the one you'll reference most often in code, and conveniently it's the default property
for the TextBox control. Three other frequently used properties are these:
• The SelStart property sets or returns the position of the blinking caret (the insertion point where
the text you type appears). Note that the blinking cursor inside TextBox and other controls is named caret,
to distinguish it from the cursor (which is implicitly the mouse cursor). When the caret is at the beginning
of the contents of the TextBox control, SelStart returns 0; when it's at the end of the string typed by the
user, SelStart returns the value Len(Text). You can modify the SelStart property to programmatically
move the caret.
• The SelLength property returns the number of characters in the portion of text that has been
highlighted by the user, or it returns 0 if there's no highlighted text. You can assign a nonzero value to this
property to programmatically select text from code. Interestingly, you can assign to this property a value
larger than the current text's length without raising a run-time error.
• The SelText property sets or returns the portion of the text that's currently selected, or it returns
an empty string if no text is highlighted. Use it to directly retrieve the highlighted text without having to
query Text, SelStart, and SelLength properties. What's even more interesting is that you can assign a
new value to this property, thus replacing the current selection with your own. If no text is currently
selected, your string is simply inserted at the current caret position.
When you want to append text to a TextBox control, you should use the following code (instead of using
the concatenation operator) to reduce flickering and improve performance:
Text1.SelStart = Len(Text1.Text)
Text1.SelText = StringToBeAdded
One of the typical operations you could find yourself performing with these properties is selecting the
entire contents of a TextBox control. You often do it when the caret enters the field so that the user can
quickly override the existing value with a new one, or start editing it by pressing any arrow key:
Private Sub Text1_GotFocus()
Text1.SelStart = 0
' A very high value always does the trick.
Text1.SelLength = 9999
End Sub
Always set the SelStart property first and then the SelLength or SelText properties. When you assign a
new value to the SelStart property, the other two are automatically reset to 0 and an empty string
respectively, thus overriding your previous settings.
The selected text can be copied to the Clipboard by using SelText:
Clipboard.SelText text, [format]
In the above syntax, text is the text that has to be placed into the Clipboard, and format has three possible
values.
1. VbCFLink - conversation information
2. VbCFRTF - Rich Text Format
3. VbCFText - Text
We can get text from the clipboard using the GetText() function this way:
Clipboard.GetText ([format])
The following Figure summarizes the common TextBox control's properties and methods.

Property/ Method Description

Properties
Enabled specifies whether user can interact with this control or not
Index Specifies the control array index
If this control is set to True user can use it else if this control is set to false
Locked
the control cannot be used
Specifies the maximum number of characters to be input. Default value is
MaxLength
set to 0 that means user can input any number of characters
MousePointer Using this we can set the shape of the mouse pointer when over a TextBox
By setting this property to True user can have more than one line in the
Multiline
TextBox
PasswordChar This is to specify mask character to be displayed in the TextBox
ScroolBars This to set either the vertical scrollbars or horizontal scrollbars to make
appear in the TextBox. User can also set it to both vertical and horizontal.
This property is used with the Multiline property.
Text Specifies the text to be displayed in the TextBox at runtime
ToolTipIndex This is used to display what text is displayed or in the control
By setting this user can make the Textbox control visible or invisible at
Visible
runtime

Method
SetFocus Transfers focus to the TextBox

Event procedures
 Change Action happens when the TextBox changes
Click Action happens when the TextBox is clicked
GotFocus Action happens when the TextBox receives the active focus
LostFocus Action happens when the TextBox loses it focus
KeyDown Called when a key is pressed while the TextBox has the focus
KeyUp Called when a key is released while the TextBox has the focus

Trapping Keyboard Activity - Visual Basic 6 TextBox Control

TextBox controls support KeyDown, KeyPress, and KeyUp standard events. One thing that you will often
do is prevent the user from entering invalid keys. A typical example of where this safeguard is needed is a
numeric field, for which you need to filter out all nondigit keys:
Private Sub Text1_KeyPress(KeyAscii As Integer)
Select Case KeyAscii
Case Is < 32 ' Control keys are OK.
Case 48 To 57 ' This is a digit.
Case Else ' Reject any other key.
KeyAscii = 0
End Select
End Sub
You should never reject keys whose ANSI code is less than 32, a group that includes important keys such
as Backspace, Escape, Tab, and Enter. Also note that a few control keys will make your TextBox beep if
it doesn't know what to do with them—for example, a single-line TextBox control doesn't know what to do
with an Enter key.
Don't assume that the KeyPress event will trap all control keys under all conditions. For example, the
KeyPress event can process the Enter key only if there's no CommandButton control on the form whose
Default property is set to True. If the form has a default push button, the effect of pressing the Enter key is
clicking on that button. Similarly, no Escape key goes through this event if there's a Cancel button on the
form. Finally, the Tab control key is trapped by a KeyPress event only if there isn't any other control on
the form whose TabStop property is True.
You can use the KeyDown event procedure to allow users to increase and decrease the current value
using Up and Down arrow keys, as you see here:
Private Sub Text1_KeyDown(KeyCode As Integer, Shift As Integer)
Select Case KeyCode
Case vbKeyUp
Text1.Text = CDbl(Text1.Text) + 1
Case vbKeyDown
Text1.Text = CDbl(Text1.Text) -1
End Select
End Sub
There's a bug in the implementation of TextBox ready-only controls. When the Locked property is set to
True, the Ctrl+C key combination doesn't correctly copy the selected text to the Clipboard, and you must
manually implement this capability by writing code in the KeyPress event procedure.

Validation Routines for Numbers - Visual Basic 6 TextBox Control

Although trapping invalid keys in the KeyPress or KeyDown event procedures seems a great idea at first,
when you throw your application to inexperienced users you soon realize that there are many ways for
them to enter invalid data. Depending on what you do with this data, your application can come to an
abrupt end with a run-time error or—much worse—it can appear to work correctly while it delivers bogus
results. What you really need is a bullet-proof method to trap invalid values.
Before I offer you a decent solution to the problem, let me explain why you can't rely solely on trapping
invalid keys for your validation chores. What if the user pastes an invalid value from the clipboard? Well,
you might say, let's trap the Ctrl+V and Shift+Ins key combinations to prevent the user from doing that!
Unfortunately, Visual Basic's TextBox controls offer a default edit menu that lets users perform any
clipboard operation by simply right-clicking on them. Fortunately, there's a way around this problem:
Instead of trapping a key before it gets to the TextBox control, you trap its effect in the Change event and
reject it if it doesn't pass your test. But this makes the structure of the code a little more complex than you
might anticipate:
' Form-level variables
Dim saveText As String
Dim saveSelStart As Long
Private Sub Text1_GotFocus()
' Save values when the control gets the focus.
saveText = Text1.Text
saveSelStart = Text1.SelStart
End Sub
Private Sub Text1_Change()
' Avoid nested calls.
Static nestedCall As Boolean
If nestedCall Then Exit Sub
' Test the control's value here.
If IsNumeric(Text1.Text) Then
' If value is OK, save values.
saveText = Text1.Text
saveSelStart = Text1.SelStart
Else
' Prepare to handle a nested call.
nestedCall = True
Text1.Text = saveText
nestedCall = False
Text1.SelStart = saveSelStart
End If
End Sub
Private Sub Text1_KeyUp(KeyCode As Integer, Shift As Integer)
saveSelStart = Text1.SelStart
End Sub
Private Sub Text1_MouseDown(Button As Integer, _
Shift As Integer, X As Single, Y As Single)
saveSelStart = Text1.SelStart
End Sub
Private Sub Text1_MouseMove(Button As Integer, _
Shift As Integer, X As Single, Y As Single)
saveSelStart = Text1.SelStart
End Sub
If the control's value doesn't pass your tests in the Change event procedure, you must restore its previous
valid value; this action recursively fires a Change event, and you must prepare yourself to neutralize this
nested call. You might wonder why you also need to trap the KeyUp, MouseDown, and MouseMove
events: The reason is that you always need to keep track of the last valid position for the insertion point
because the end user could move it using arrow keys or the mouse.
The preceding code snippet uses the IsNumeric function to trap invalid data. You should be aware that
this function isn't robust enough for most real-world applications. For example, the IsNumeric function
incorrectly considers these strings as valid numbers:
123,,,123
345-
$1234 ' What if it isn't a currency field?
2.4E10 ' What if I don't want to support scientific notation?
To cope with this issue, I have prepared an alternative function, which you can modify for your particular
purposes. (For instance, you can add support for a currency symbol or the comma as the decimal
separator.) Note that this function always returns True when it's passed a null string, so you might need to
perform additional tests if the user isn't allowed to leave the field blank:
Function CheckNumeric(text As String, DecValue As Boolean) As Boolean
Dim i As Integer
For i = 1 To Len(text)
Select Case Mid$(text, i, 1)
Case "0" To "9"
Case "-", "+"
' Minus/plus signs are only allowed as leading chars.
If i > 1 Then Exit Function
Case "."
' Exit if decimal values not allowed.
If Not DecValue Then Exit Function
' Only one decimal separator is allowed.
If InStr(text, ".") < i Then Exit Function
Case Else
' Reject all other characters.
Exit Function
End Select
Next
CheckNumeric = True
End Function
If your TextBox controls are expected to contain other types of data, you might be tempted to reuse the
same validation framework I showed you previously—including all the code in the GotFocus, Change,
KeyUp, MouseDown, and MouseMove event procedures—and replace only the call to IsNumeric with a
call to your custom validation routine. Things aren't as simple as they appear at first, however. Say that
you have a date field: Can you use the IsDate function to validate it from within the Change event? The
answer is, of course, no. In fact, as you enter the first digit of your date value, IsDate returns False and
the routine therefore prevents you from entering the remaining characters, and so preventing you from
entering any value.
This example explains why a key-level validation isn't always the best answer to your validation needs.
For this reason, most Visual Basic programmers prefer to rely on field-level validation and test the values
only when the user moves the input focus to another field in the form. I explain field-level validation in the
next section.

The CausesValidation Property and the Validate Event - Visual

Basic 6 TextBox Control
Visual Basic 6 has finally come up with a solution for most of the validation issues that have afflicted
Visual Basic developers for years. As you'll see in a moment, the Visual Basic 6 approach is simple and
clean; it really astonishes me that it took six language versions to deliver such a lifesaver. The keys to the
new validation features are the Validate event and the CausesValidation property. They work together as
follows: When the input focus leaves a control, Visual Basic checks the CausesValidation property of the
control that is about to receive the focus. If this property is True, Visual Basic fires the Validate event in
the control that's about to lose the focus, thus giving the programmer a chance to validate its contents
and, if necessary, cancel the focus shift.
Let's try a practical example. Imagine that you have five controls on a form: a required field (a TextBox
control, txtRequired, that can't contain an empty string), a numeric field, txtNumeric, that expects a value
in the range 1 through 1000, and three push buttons: OK, Cancel, and Help. (See the figure below.) You
don't want to perform validation if the user presses the Cancel or Help buttons, so you set their
CausesValidation properties to False. The default value for this property is True, so you don't have to
modify it for the other controls. Run the sample program on the companion CD, type something in the
required TextBox, and then move to the second field. Because the second field's CausesValidation
property is True, Visual Basic fires a Validate event in the first TextBox control:
Private Sub txtRequired_Validate(Cancel As Boolean)
' Check that field is not empty.
If txtRequired.Text = "" Then
MsgBox "Please enter something here", vbExclamation
Cancel = True
End If
End Sub
If the Cancel parameter is set to True, Visual Basic cancels the user's action and takes the input focus
back on the txtRequired control: No other GotFocus and LostFocus events are generated. On the other
hand, if you typed something in the required field, the focus will now be on the second field (the numeric
text box). Try clicking on the Help or Cancel buttons: No Validate event will fire this time because you set
the CausesValidation property for each of these controls to False. Instead, click on the OK button to
execute the Validate event of the numeric field, where you can check it for invalid characters and valid
range.

A demonstration program that lets you experiment with the new Visual Basic Validate features
Private Sub txtNumeric_Validate(Cancel As Boolean)
If Not IsNumeric(txtNumeric.Text) Then
Cancel = True
ElseIf CDbl(txtNumeric.Text) < 1 Or CDbl(txtNumeric.Text) > 1000 Then
Cancel = True
End If
If Cancel Then
MsgBox "Please enter a number in range [1-1000]", vbExclamation
End If
End Sub
In some circumstances, you might want to programmatically validate the control that has the focus without
waiting for the user to move the input focus. You can do it with the form's ValidateControls method, which
forces the Validate event of the control that has the input focus. Typically, you do it when the user closes
the form:
Private Sub Form_QueryUnload(Cancel As Integer, UnloadMode As Integer)
' You can't close this form without validating the current field.
If UnloadMode = vbFormControlMenu Then
On Error Resume Next
ValidateControls
If Err = 380 Then
' The current field failed validation.
Cancel = True
End If
End If
End Sub
Checking the UnloadMode parameter is important; otherwise, your application will mistakenly execute a
ValidateControls method when the user clicks on the Cancel button. Note that ValidateControls returns an
error 380 if Cancel was set in the Validate event procedure of the control that had the focus.
Visual Basic 6's validation scheme has two flaws, though. If your form has a CommandButton whose
Default property is set to True, pressing the Enter key while the input focus is on another control results in
a click on the CommandButton control but doesn't fire a Validate event, even if the CausesValidation
property of the CommandButton control is set to True. The only way to solve this problem is to invoke the
ValidateControls method from within the default CommandButton control's Click event procedure.
The second flaw is that the Validate event doesn't fire when you're moving the focus from a control whose
CausesValidation property is False, even if the control that receives the focus has its CausesValidation
property set to True.
The new Visual Basic 6 validation mechanism is simple and can be implemented with little effort. But it
isn't the magic answer to all your validation needs. In fact, this technique can only enforce field-level
validation; it does nothing for record-level validation. In other words, it ensures that one particular field is
correct, not that all fields in the form contain valid data. To see what I mean, run the demonstration
program, enter a string in the first field, and press Alt+F4 to close the form. Your code won't raise an
error, even if the second field doesn't contain a valid number! Fortunately, it doesn't take much to create a
generic routine that forces each control on the form to validate itself:
Private Sub Form_QueryUnload(Cancel As Integer, UnloadMode As Integer)
' You can't close this form without validating all the fields on it.
If UnloadMode = vbFormControlMenu Then
On Error Resume Next
Dim ctrl As Control
' Give the focus to each control on the form, and then
' validate it.
For Each ctrl In Controls
Err.Clear
ctrl.SetFocus
If Err = 0 Then
' Don't validate controls that can't receive input focus.
ValidateControls
If Err = 380 Then
' Validation failed, refuse to close.
Cancel = True: Exit Sub
End If
End If
Next
End If
End Sub
The CausesValidation property and the Validate event are shared by all the intrinsic controls that are able
to get the focus as well as by most external ActiveX controls, even those not specifically written for Visual
Basic. This is possible because they are extender features, provided by the Visual Basic runtime to all the
controls placed on a form's surface.
One Visual Basic operator has great potential when it comes time to validate complex strings but is
neglected by most Visual Basic developers. Let's say you have a product code that consists of two
uppercase characters followed by exactly three digits. You might think that you need some complex string
functions to validate such a string until you try the Like operator, as follows:
If "AX123" Like "[A-Z][A-Z]###" Then Print "OK"

Multiline TextBox Controls - Visual Basic 6 TextBox Control

You create multiline TextBox controls by setting the MultiLine property to True and the ScrollBars property
to 2-Vertical or 3-Both. A vertical scroll bar causes the contents of the control to automatically wrap when
a line is too long for the control's width, so this setting is most useful when you're creating memo fields or
simple word processor-like programs. If you have both a vertical and a horizontal scroll bar, the TextBox
control behaves more like a programmer's editor, and longer lines simply extend beyond the right border.
I've never found a decent use for the other settings of the ScrollBars property (0-None and 1-Horizontal)
in a multiline TextBox control. Visual Basic ignores the ScrollBars property if MultiLine is False.
Both these properties are read-only at run time, which means that you can't alternate between a regular
and a multiline text box, or between a word processor-like multiline field (ScrollBars = 2-Vertical) and an
editorlike field (ScrollBars = 3-Both). To tell the whole truth, Visual Basic's support for multiline TextBox
controls leaves much to be desired. You can do very little with such controls at run time, except to retrieve
and set their Text properties. When you read the contents of a multiline TextBox control, it's up to you to
determine where each line of text starts and ends. You do this with a loop that searches for carriage
return (CR) and line feed (LF) pairs, or even more easily using the new Split string function:
' Print the lines of text in Text1, labeling them with their line numbers.
Dim lines() As String, i As Integer
lines() = Split(Text1.Text, vbCrLf)
For i = 0 To UBound(lines)
Print (i + 1) & ": " & lines(i)
Next
The support offered by Visual Basic for multiline TextBox controls ends here. The language doesn't offer
any means for learning such vital information as at which point each line of text wraps, which are the first
visible line and the first visible column, which line and column the caret is on, and so on. Moreover, you
have no means of programmatically scrolling through a multiline text box. The solutions to these problems
require Microsoft Windows API programming. In my opinion, however, Visual Basic should offer these
features as built-in properties and methods.
You should account for two minor issues when including one or more multiline TextBox controls on your
forms. When you enter code in a word processor or an editor, you expect that the Enter key will add a
newline character (more precisely, a CR-LF character pair) and that the Tab key will insert a tab character
and move the caret accordingly. Visual Basic supports these keys, but because both of them have special
meaning to Windows the support is limited: The Enter key adds a CR-LF pair only if there isn't a default
push button on the form, and the Tab key inserts a tab character only if there aren't other controls on the
form whose TabStop property is set to True. In many circumstances, these requirements can't be met,
and some of your users will find your user interface annoying. If you can't avoid this problem, at least add
a reminder to your users that they can add new lines using the Ctrl+Enter key combination and insert tab
characters using the Ctrl+Tab key combination. Another possible approach is to set the TabStop property
to False for all the controls in the form in the multiline TextBox's GotFocus event and to restore the
original values in the LostFocus event procedure.

Label and Frame Controls in Visual Basic 6 (VB6)

Label and Frame controls have a few features in common, so it makes sense to explain them together.
First they're mostly "decorative" controls that contribute to the user interface but are seldom used as
programmable objects. In other words, you often place them on the form and arrange their properties as
your user interface needs dictate, but you rarely write code to serve their events, generally, or manipulate
their properties at run time.
Label Controls
Most people use Label controls to provide a descriptive caption and possibly an associated hot key for
other controls, such as TextBox, ListBox, and ComboBox, that don't expose the Caption property. In most
cases, you just place a Label control where you need it, set its Caption property to a suitable string
(embedding an ampersand character in front of the hot key you want to assign), and you're done. Caption
is the default property for Label controls. Be careful to set the Label's TabIndex property so that it's 1
minus the TabIndex property of the companion control.
Other useful properties are BorderStyle(if you want the Label control to appear inside a 3D border) and
Alignment (if you want to align the caption to the right or center it on the control). In most cases, the
alignment depends on how the Label control relates to its companion control: for example, if the Label
control is placed to the left of its companion field, you might want to set its Alignment property to 1-Right
Justify. The value 2-Center is especially useful for stand-alone Label controls.

Different settings for the Alignment property of Label controls.

You can insert a literal & character in a Label control's Caption property by doubling it. For example, to
see Research & Development you have to type &Research && Development. Note that if you have
multiple but isolated &s, the one that selects the hot key is the last one and all others are ignored. This tip
applies to all the controls that expose a Caption property. (The & has no special meaning in forms'
Caption properties, however.)
If the caption string is a long one, you might want to set the Label's WordWrap property to True so that it
will extend for multiple lines instead of being truncated by the right border of the control. Alternatively, you
might decide to set the AutoSize property to True and let the control automatically resize itself to
accommodate longer caption strings.
You sometimes need to modify the default value of a Label's BackStyle property. Label controls usually
cover what's already on the form's surface (other lightweight controls, output from graphic methods, and
so on) because their background is considered to be opaque. If you want to show a character string
somewhere on the form but at the same time you don't want to obscure underlying objects, set the
BackStyle property to 0-Transparent.
If you're using the Label control to display data read from elsewhere—for example, a database field or a
text file—you should set its UseMnemonics property to False. In this case, & characters have no special
meaning to the control, and so you indirectly turn off the control's hot key capability. I mention this
property because in older versions of Visual Basic, you had to manually double each & character to make
the ampersand appear in text. I don't think all developers are aware that you can now treat ampersands
like regular characters.
As I said before, you don't usually write code in Label control event procedures. This control exposes only
a subset of the events supported by other controls. For example, because Label controls can never get
the input focus, they don't support GotFocus, LostFocus, or any keyboard-related events. In practice, you
can take advantage only of their mouse events: Click, DblClick, MouseDown, MouseMove, and MouseUp.
If you're using a Label control to display data read from a database, you might sometimes find it useful to
write code in its Change event. A Label control doesn't expose a specific event that tells programmers
when users press its hot keys.
You can do some interesting tricks with Label controls. For example, you can use them to provide
rectangular hot spots for images loaded onto the form. To create that context-sensitive ToolTip, I loaded
the image on the form using the form's Picture property and then I placed a Label control over the
Microsoft BackOffice logo, setting its Caption property to an empty string and the BackStyle property to 0-
Transparent. These properties make the Label invisible, but it correctly shows its ToolTip when
necessary. And because it still receives all mouse events, you can use its Click event to react to users'
actions.
Frame Controls
Frame controls are similar to Label controls in that they can serve as captions for those controls that don't
have their own. Moreover, Frame controls can also (and often do) behave as containers and host other
controls. In most cases, you only need to drop a Frame control on a form and set its Caption property. If
you want to create a borderless frame, you can set its BorderStyle property to 0-None.
Controls that are contained in the Frame control are said to be child controls. Moving a control at design
time over a Frame control—or over any other container, for that matter—doesn't automatically make that
control a child of the Frame control. After you create a Frame control, you can create a child control by
selecting the child control's icon in the Toolbox and drawing a new instance inside the Frame's border.
Alternatively, to make an existing control a child of a Frame control, you must select the control, press
Ctrl+X to cut it to the Clipboard, select the Frame control, and press Ctrl+V to paste the control inside the
Frame. If you don't follow this procedure and you simply move the control over the Frame, the two
controls remain completely independent of each other, even if the other control appears in front of the
Frame control.
Frame controls, like all container controls, have two interesting features. If you move a Frame control, all
the child controls go with it. If you make a container control disabled or invisible, all its child controls also
become disabled or invisible. You can exploit these features to quickly change the state of a group of
related controls.

VB6 CommandButton and OptionButton Controls - Visual Basic 6

When compared to TextBox controls, these controls are really simple. Not only do they expose relatively
few properties, they also support a limited number of events, and you don't usually write much code to
manage them.
 CommandButton Controls in VB6
Using CommandButton controls is trivial. In most cases, you just draw the control on the form's surface,
set its Caption property to a suitable string (adding an & character to associate a hot key with the control if
you so choose), and you're finished, at least with user-interface issues. To make the button functional,
you write code in its Click event procedure, as in this fragment:
Private Sub Command1_Click()
' Save data, then unload the current form.
Call SaveDataToDisk
Unload Me
End Sub
You can use two other properties at design time to modify the behavior of a CommandButton control. You
can set the Default property to True if it's the default push button for the form (the button that receives a
click when the user presses the Enter key—usually the OK or Save button). Similarly, you can set the
Cancel property to True if you want to associate the button with the Escape key.
The only relevant CommandButton's run-time property is Value, which sets or returns the state of the
control (True if pressed, False otherwise). Value is also the default property for this type of control. In
most cases, you don't need to query this property because if you're inside a button's Click event you can
be sure that the button is being activated. The Value property is useful only for programmatically clicking
a button:
This fires the button's Click event.
Command1.Value = True
The CommandButton control supports the usual set of keyboard and mouse events (KeyDown, KeyPress,
KeyUp, MouseDown, MouseMove, MouseUp, but not the DblClick event) and also the GotFocus and
LostFocus events, but you'll rarely have to write code in the corresponding event procedures.

Properties of a CommandButton control

• To display text on a CommandButton control, set its Caption property.
• An event can be activated by clicking on the CommandButton.
• To set the background colour of the CommandButton, select a colour in the BackColor property.
• To set the text colour set the Forecolor property.
• Font for the CommandButton control can be selected using the Font property.
• To enable or disable the buttons set the Enabled property to True or False
• To make visible or invisible the buttons at run time, set the Visible property to True or False.
• Tooltips can be added to a button by setting a text to the Tooltip property of the CommandButton.
• A button click event is handled whenever a command button is clicked. To add a click event handler, double click the
button at design time, which adds a subroutine like the one given below.

Private Sub Command1_Click( )

..................
End Sub

OptionButton Controls in VB6

OptionButton controls are also known as radio buttons because of their shape. You always use
OptionButton controls in a group of two or more because their purpose is to offer a number of mutually
exclusive choices. Anytime you click on a button in the group, it switches to a selected state and all the
other controls in the group become unselected.
Preliminary operations for an OptionButton control are similar to those already described for CheckBox
controls. You set an OptionButton control's Caption property to a meaningful string, and if you want you
can change its Alignment property to make the control right aligned. If the control is the one in its group
that's in the selected state, you also set its Valueproperty to True. (The OptionButton's Value property is a
Boolean value because only two states are possible.) Value is the default property for this control.
At run time, you typically query the control's Value property to learn which button in its group has been
selected. Let's say you have three OptionButton controls, named optWeekly, optMonthly, and optYearly.
You can test which one has been selected by the user as follows:
If optWeekly.Value Then
' User prefers weekly frequency.
ElseIf optMonthly.Value Then
' User prefers monthly frequency.
ElseIf optYearly.Value Then
' User prefers yearly frequency.
End If
Strictly speaking, you can avoid the test for the last OptionButton control in its group because all choices
are supposed to be mutually exclusive. But the approach I just showed you increases the code's
readability.
A group of OptionButton controls is often hosted in a Frame control. This is necessary when there are
other groups of OptionButton controls on the form. As far as Visual Basic is concerned, all the
OptionButton controls on a form's surface belong to the same group of mutually exclusive selections,
even if the controls are placed at the opposite corners of the window. The only way to tell Visual Basic
which controls belong to which group is by gathering them inside a Frame control. Actually, you can group
your controls within any control that can work as a container—PictureBox, for example—but Frame
controls are often the most reasonable choice.
Example
Open a new Standard EXE project and the save the Form as Option.frm and save the project as
Option.vbp.
Design the Form as per the following specifications table.
Object Property Settings

Label Caption Enter a Number

Name Label1

TextBox Text (empty)

Name Text1

CommandButton Caption &Close

Name Command1

OptionButton Caption &Octal

Name optOct

OptionButton Caption &Hexadecimal

Name optHex

OptionButton Caption &Decimal

Name optDec

The application responds to the following events

• The change event of the TextBox reads the value and stores it in a form-level numeric variable.
• The click event of optOct button returns curretval in octal.
• The click event of the optHex button curerntval in hexadecimal
• The click event of the optDec button returns the decimal equivalent of the value held currentval.
The following code is entered in the general declarations section of the Form.
Dim currentval as variant
The variable is initialized to 0 by default. The change event procedure checks to ascertain the number
system (Octal, Hexadecimal) that is in effect and then reads in the number.
Private Sub Text1_Change()
If optOct.Value = True Then
currentval = Val ("&O" & LTrim (Text1.Text) & "&")
Elseif optDec.value = True Then
currentval = Val (LTrim (Text1.Text) & "&")
Else
currentval = Val ("&H" & LTrim (Text1.Text) & "&")
End if
End Sub
The Val function is used to translate string to a number and can recognize Octal and Hexadecimal strings.
The LTrim function trims the leading blanks in the text. The following code is entered in the click events of
the OptionButton controls.
Private Sub optOct_Click()
Text1.Text = Oct(currentval)
End Sub
Private Sub optHex_Click()
Text1.Text = Hex(currentval)
End Sub
Private Sub optDec_Click()
Text1.Text = Format(currentval)
End Sub
The follwoing code is entered in the click event of teh Close button.
Private Sub cmdClose_Click()
Unlod Me
End Sub
The Application is run by pressing F5 or clicking on the Run icon in the tool bar. By pressing the Exit
button the program is terminated.

PictureBox and Image Controls in Visual Basic 6

Both PictureBox and Image controls let you display an image, so let's compare them and see when it
makes sense to choose one or the other.
The PictureBox Control
PictureBox controls are among the most powerful and complex items in the Visual Basic Toolbox window.
In a sense, these controls are more similar to forms than to other controls. For example, PictureBox
controls support all the properties related to graphic output, including AutoRedraw, ClipControls, HasDC,
FontTransparent, CurrentX, CurrentY, and all the Drawxxxx, Fillxxxx, and Scalexxxx properties.
PictureBox controls also support all graphic methods, such as Cls, PSet, Point, Line, and Circle and
conversion methods, such as ScaleX, ScaleY, TextWidth, and TextHeight. In other words, all the
techniques that I described for forms can also be used for PictureBox controls (and therefore won't be
covered again in this section).
Loading images
Once you place a PictureBox on a form, you might want to load an image in it, which you do by setting the
Picture property in the Properties window. You can load images in many different graphic formats,
including bitmaps (BMP), device independent bitmaps (DIB), metafiles (WMF), enhanced metafiles
(EMF), GIF and JPEG compressed files, and icons (ICO and CUR). You can decide whether a control
should display a border, resetting the BorderStyle to 0-None if necessary. Another property that comes
handy in this phase is AutoSize: Set it to True and let the control automatically resize itself to fit the
assigned image.
You might want to set the Align property of a PictureBox control to something other than the 0-None
value. By doing that, you attach the control to one of the four form borders and have Visual Basic
automatically move and resize the PictureBox control when the form is resized. PictureBox controls
expose a Resize event, so you can trap it if you need to move and resize its child controls too.
You can do more interesting things at run time. To begin with, you can programmatically load any image
in the control using the LoadPicture function:
Picture1.Picture = LoadPicture("c:\windows\setup.bmp")
and you can clear the current image using either one of the following statements:
' These are equivalent.
Picture1.Picture = LoadPicture("")
Set Picture1.Picture = Nothing
The LoadPicture function has been extended in Visual Basic 6 to support icon files containing multiple
icons. The new syntax is the following:
LoadPicture(filename, [size], [colordepth], [x], [y])
where values in square brackets are optional. If filename is an icon file, you can select a particular icon
using the size or colordepth arguments. Valid sizes are 0-vbLPSmall, 1-vbLPLarge (system icons whose
sizes depend on the video driver), 2-vbLPSmallShell, 3-vbLPLargeShell (shell icons whose dimensions
are affected by the Caption Button property as set in the Appearance tab in the screen's Properties dialog
box), and 4-vbLPCustom (size is determined by x and y). Valid color depths are 0-vbLPDefault (the icon
in the file that best matches current screen settings), 1-vbLPMonochrome, 2-vbLPVGAColor (16 colors),
and 3-vbLPColor (256 colors).
You can copy an image from one PictureBox control to another by assigning the target control's Picture
property:
Picture2.Picture = Picture1.Picture

The PaintPicture method

PictureBox controls are equipped with a very powerful method that enables the programmer to perform a
wide variety of graphic effects, including zooming, scrolling, panning, tiling, flipping, and many fading
effects: This is the PaintPicture method. (This method is also exposed by form objects, but it's most often
used with PictureBox controls.) In a nutshell, this method performs a pixel-by-pixel copy from a source
control to a destination control. The complete syntax of this method is complex and rather confusing:
DestPictBox.PaintPicture SrcPictBox.Picture, destX, destY, [destWidth], _
[destHeight], [srcX], [srcY2], [srcWidth], [srcHeight], [Opcode])
The only required arguments are the source PictureBox control's Picture property and the coordinates
inside the destination control where the image must be copied. The destX / destY arguments are
expressed in the ScaleMode of the destination control; by varying them, you can make the image appear
exactly where you want. For example, if the source PictureBox control contains a bitmap 3000 twips wide
and 2000 twips tall, you can center this image on the destination control with this command:
picDest.PaintPicture picSource.Picture, (picDest.ScaleWidth - 3000) / 2, _
(picDest.ScaleHeight - 2000) / 2
In general, Visual Basic doesn't provide a way to determine the size of a bitmap loaded into a PictureBox
control. But you can derive this information if you set the control's AutoSize property to True and then
read the control's ScaleWidth and ScaleHeight properties. If you don't want to resize a visible control just
to learn the dimensions of a bitmap, you can load it into an invisible control, or you can use this trick,
based on the fact that the Picture property returns an StdPicture object, which in turn exposes the Height
and Width properties:
' StdPicture's Width and Height properties are expressed in
' Himetric units.
With Picture1
width = CInt(.ScaleX(.Picture.Width, vbHimetric, vbPixels))
height = CInt(.ScaleY(.Picture.Height, vbHimetric, _
vbPixels))
End With
By the way, in all subsequent code examples I assume that the source PictureBox control's ScaleWidth
and ScaleHeight properties match the actual bitmap's size. By default, the PaintPicture method copies the
entire source bitmap. But you can copy just a portion of it, passing a value for srcWidth and srcHeight:
' Copy the upper left portion of the source image.
picDest.PaintPicture picSource.Picture, 0, 0, , , , , _
picSource.ScaleWidth / 2, picSource.ScaleHeight / 2
If you're copying just a portion of the source image, you probably want to pass a specific value for the
srcX and srcY values as well, which correspond to the coordinates of the top-left corner of the area that
will be copied from the source control:
' Copy the bottom-right portion of the source image
' in the corresponding corner in the destination.
wi = picSource.ScaleWidth / 2
he = picSource.ScaleHeight / 2
picDest.PaintPicture picSource.Picture, wi, he, , , wi, he, wi, he
You can use this method to tile a target PictureBox control (or form) with multiple copies of an image
stored in another control:
' Start with the leftmost column.
x = 0
Do While x < picDest.ScaleWidth
y = 0
' For each column, start at the top and work downward.
Do While y < picDest.ScaleHeight
picDest.PaintPicture picSource.Picture, x, y, , , 0, 0
' Next row
y = y + picSource.ScaleHeight
Loop
' Next column
x = x + picSource.ScaleWidth
Loop
Another great feature of the PaintPicture method lets you resize the image while you transfer it, and you
can even specify different zoom-in and zoom-out factors for the x- and y-axes independently. You just
have to pass a value to the destWidth and destHeight arguments: If these values are greater than the
source image's corresponding dimensions, you achieve a zoom-in effect, and if they are less you get a
zoom-out effect. For example, see how you can double the size of the original image:
picDest.PaintPicture picSource.Picture, 0, 0, _
picSource.ScaleWidth * 2, picSource.ScaleHeight * 2
As a special case of the syntax of the PaintPicture method, the source image can even be flipped along
its x-axis, y-axis, or both by passing negative values for these arguments:
' Flip horizontally.
picDest.PaintPicture picSource.Picture, _
picSource.ScaleWidth, 0, -picSource.ScaleWidth
' Flip vertically.
picDest.PaintPicture picSource.Picture, 0, _
picSource.ScaleHeight, , -picSource.ScaleHeight
' Flip the image on both axes.
picDest.PaintPicture picSource.Picture, picSource.ScaleWidth, _
picSource.ScaleHeight, -picSource.ScaleWidth, -picSource.ScaleHeight
As you might expect, you can combine all these effects together, magnifying, reducing, or flipping just a
portion of the source image, and have the result appear in any point of the destination PictureBox control
(or form). You should find no problem in reusing all those routines in your own applications.
As if all these capabilities weren't enough, we haven't covered the last argument of the PaintPicture
method yet. The opcode argument lets you specify which kind of Boolean operation must be performed
on pixel bits as they're transferred from the source image to the destination. The values you can pass to
this argument are the same that you assign to the DrawMode property. The default value is 13-
vbCopyPen, which simply copies the source pixels in the destination control. By playing with the other
settings, you can achieve many interesting graphical effects, including simple animations.
The Image Control
Image controls are far less complex than PictureBox controls. They don't support graphical methods or
the AutoRedraw and the ClipControls properties, and they can't work as containers, just to hint at their
biggest limitations. Nevertheless, you should always strive to use Image controls instead of PictureBox
controls because they load faster and consume less memory and system resources. Remember that
Image controls are windowless objects that are actually managed by Visual Basic without creating a
Windows object. Image controls can load bitmaps and JPEG and GIF images.
When you're working with an Image control, you typically load a bitmap into its Picture property either at
design time or at run time using the LoadPicture function. Image controls don't expose the AutoSize
property because by default they resize to display the contained image (as it happens with PictureBox
controls set at AutoSize = True). On the other hand, Image controls support a Stretch property that, if
True, resizes the image (distorting it if necessary) to fit the control. In a sense, the Stretch property
somewhat remedies the lack of the PaintPicture method for this control. In fact, you can zoom in to or
reduce an image by loading it in an Image control and then setting its Stretch property to True to change
its width and height:
' Load a bitmap.
Image1.Stretch = False
Image1.Picture = LoadPicture("c:\windows\setup.bmp")
' Reduce it by a factor of two.
Image1.Stretch = True
Image1.Move 0, 0, Image1.Width / 2, Image1.Width / 2
Image controls support all the usual mouse events. For this reason, many Visual Basic developers have
used Image controls to simulate graphical buttons and toolbars. Now that Visual Basic natively supports
these controls, you'd probably better use Image controls only for what they were originally intended.

The Timer, Line, Shape and OLE Controls in Visual Basic 6 (VB6)
The Timer Control
A Timer control is invisible at run time, and its purpose is to send a periodic pulse to the current
application. You can trap this pulse by writing code in the Timer's Timer event procedure and take
advantage of it to execute a task in the background or to monitor a user's actions. This control exposes
only two meaningful properties: Interval and Enabled. Interval stands for the number of milliseconds
between subsequent pulses (Timer events), while Enabled lets you activate or deactivate events. When
you place the Timer control on a form, its Interval is 0, which means no events. Therefore, remember to
set this property to a suitable value in the Properties window or in the Form_Load event procedure:
Private Sub Form_Load()
Timer1.Interval = 500 ' Fire two Timer events per second.
End Sub
Timer controls let you write interesting programs with just a few lines of code. The typical (and abused)
example is a digital clock. Just to make things a bit more compelling, I added flashing colons:
Private Sub Timer1_Timer()
Dim strTime As String
strTime = Time$
If Mid$(lblClock.Caption, 3, 1) = ":" Then
Mid$(strTime, 3, 1)= " "
Mid$(strTime, 6, 1) = " "
End If
lblClock.Caption = strTime
End Sub
You must be careful not to write a lot of code in the Timer event procedure because this code will be
executed at every pulse and therefore can easily degrade your application's performance. Just as
important, never execute a DoEvents statement inside a Timer event procedure because you might cause
the procedure to be reentered, especially if the Interval property is set to a small value and there's a lot of
code inside the procedure.
Timer controls are often useful for updating status information on a regular basis. For example, you might
want to display on a status bar a short description of the control that currently has the input focus. You
can achieve that by writing some code in the GotFocus event for all the controls on the form, but when
you have dozens of controls this will require a lot of code (and time). Instead, at design time load a short
description for each control in its Tag property, and then place a Timer control on the form with an Interval
setting of 500. This isn't a time-critical task, so you can use an even larger value. Finally add two lines of
code to the control's Timer event:
Private Sub Timer1_Timer()
On Error Resume Next
lblStatusBar.Caption = ActiveControl.Tag
End Sub

The Line Control

The Line control is a decorative control whose only purpose is let you draw one or more straight lines at
design time, instead of displaying them using a Line graphical method at run time. This control exposes a
few properties whose meaning should sound familiar to you by now: BorderColor (the color of the line),
BorderStyle (the same as a form's DrawStyle property), BorderWidth (the same as a form's DrawWidth
property), and DrawMode. While the Line control is handy, remember that using a Line method at run
time is usually better in terms of performance.
The Shape Control
In a sense, the Shape control is an extension of the Line control. It can display six basic shapes:
Rectangle, Square, Oval, Circle, Rounded Rectangle, and Rounded Square. It supports all the Line
control's properties and a few more: BorderStyle (0-Transparent, 1-Solid), FillColor, and FillStyle (the
same as a form's properties with the same names). The same performance considerations I pointed out
for the Line control apply to the Shape control.
The OLE Control
When OLE first made its appearance, the concept of Object Linking and Embedding seemed to most
developers nothing short of magic. The ability to embed a Microsoft Word Document or a Microsoft Excel
worksheet within another Windows application seemed an exciting one, and Microsoft promptly released
the OLE control—then called the OLE Container control—to help Visual Basic support this capability.
In the long run, however, the Embedding term in OLE has lost much of its appeal and importance, and
nowadays programmers are more concerned and thrilled about Automation, a subset of OLE that lets
them control other Windows applications from the outside, manipulating their object hierarchies through
OLE. For this reason, I won't describe the OLE control: It's a rather complex object, and a thorough
description of its many properties, methods, and events (and quirks) would take too much space.

Using ListBox and ComboBox Controls In Visual Basic 6

ListBox and ComboBox controls present a set of choices that are displayed vertically in a column. If the
number of items exceed the value that be displayed, scroll bars will automatically appear on the control.
These scroll bars can be scrolled up and down or left to right through the list.
The following Fig lists some of the common ComboBox properties and methods.
Property/Method Description
Properties
By setting this property to True or False user can decide whether user
Enabled
can interact with this control or not
Index Specifies the Control array index
String array. Contains the strings displayed in the drop-down list.
List
Starting array index is 0.
ListCount Integer. Contains the number of drop-down list items
Integer. Contains the index of the selected ComboBox item. If an item
ListIndex
is not selected, ListIndex is -1
Locked Boolean. Specifies whether user can type or not in the ComboBox
Integer. Specifies the shape of the mouse pointer when over the area of
MousePointer
the ComboBox
Integer. Index of the last item added to the ComboBox. If the
NewIndex
ComboBox does not contain any items , NewIndex is -1
Sorted Boolean. Specifies whether the ComboBox's items are sorted or not.
Style Integer. Specifies the style of the ComboBox's appearance
TabStop Boolean. Specifies whether ComboBox receives the focus or not.
Text String. Specifies the selected item in the ComboBox
ToolTipIndex String. Specifies what text is displayed as the ComboBox's tool tip
Visible Boolean. Specifies whether ComboBox is visible or not at run time
Methods
AddItem Add an item to the ComboBox
Clear Removes all items from the ComboBox
RemoveItem Removes the specified item from the ComboBox
SetFocus Transfers focus to the ComboBox
Event Procedures
Change Called when text in ComboBox is changed
DropDown Called when the ComboBox drop-down list is displayed
GotFocus Called when ComboBox receives the focus
LostFocus Called when ComboBox loses it focus

Adding items to a List

It is possible to populate the list at design time or run time
Design Time : To add items to a list at design time, click on List property in the property box and then
add the items. Press CTRL+ENTER after adding each item as shown below.
Run Time : The AddItem method is used to add items to a list at run time. The AddItem method uses the
following syntax.
Object.AddItemitem, Index
The item argument is a string that represents the text to add to the list
The index argument is an integer that indicates where in the list to add the new item. Not giving the index
is not a problem, because by default the index is assigned.
Following is an example to add item to a combo box. The code is typed in the Form_Load event
Private Sub Form_Load()
Combo1.AddItem 1
Combo1.AddItem 2
Combo1.AddItem 3
Combo1.AddItem 4
Combo1.AddItem 5
Combo1.AddItem 6
End Sub

Removing Items from a List

The RemoveItem method is used to remove an item from a list. The syntax for this is given below.
Object.RemoveItem index
The following code verifies that an item is selected in the list and then removes the selected item from the
list.
Private Sub cmdRemove_Click()
If List1.ListIndex > -1 Then
List1.RemoveItem List1. ListIndex
End If
End Sub

Sorting the List

The Sorted property is set to True to enable a list to appear in alphanumeric order and False to display
the list items in the order which they are added to the list.
Using the ComboBox
A ComboBox combines the features of a TextBox and a ListBox. This enables the user to select either by
typing text into the ComboBox or by selecting an item from the list. There are three types of ComboBox
styles that are represented as shown below.

Simple combo
Dropdown combo Dropdown list

• Dropdown Combo (style 0)

• Simple Combo (style 1)
• Dropdown List (style 2)
The Simple Combo box displays an edit area with an attached list box always visible immediately below
the edit area. A simple combo box displays the contents of its list all the time. The user can select an item
from the list or type an item in the edit box portion of the combo box. A scroll bar is displayed beside the
list if there are too many items to be displayed in the list box area.
The Dropdown Combo box first appears as only an edit area with a down arrow button at the right. The
list portion stays hidden until the user clicks the down-arrow button to drop down the list portion. The user
can either select a value from the list or type a value in the edit area.
The Dropdown list combo box turns the combo box into a Dropdown list box. At run time , the control
looks like the Dropdown combo box. The user could click the down arrow to view the list. The difference
between Dropdown combo & Dropdown list combo is that the edit area in the Dropdown list combo is
disabled. The user can only select an item and cannot type anything in the edit area. Anyway this area
displays the selected item.
Example
This example is to Add , Remove, Clear the list of items and finally close the application.
• Open a new Standard EXE project is opened an named the Form as Listbox.frm and save the
project as Listbox.vbp
• Design the application as shown below.
Object Property Settings
Caption ListBox
Form
Name frmListBox

Text (empty)
TextBox
Name txtName

Caption Enter a name

Label
Name lblName
ListBox Name lstName
Caption Amount Entered
Label
Name lblAmount

Caption (empty)
Label Name lblDisplay
Border Style 1 Fixed Single

Caption Add
CommandButton
Name cmdAdd
CommandButton Caption Remove
 Name cmdRemove

Caption Clear
CommandButton
Name cmdClear

Caption Exit
CommandButton
Name cmdExit

The following event procedures are entered for the TextBox and CommandButton controls.
Private Sub txtName_Change()
If (Len(txtName.Text) > 0) Then 'Enabling the Add button
'if atleast one character
'is entered
cmdAdd.Enabled = True
End If
End Sub
Private Sub cmdAdd_Click()
lstName.AddItem txtName.Text 'Add the entered the characters to the list box

txtName.Text = "" 'Clearing the text box

txtName.SetFocus 'Get the focus back to the

'text box

lblDisplay.Caption = lstName.ListCount 'Display the number of items in the

list box

cmdAdd.Enabled = False ' Disabling the Add button

End Sub
The click event of the Add button adds the text to the list box that was typed in the Text box. Then the text
box is cleared and the focus is got to the text box. The number of entered values will is increased
according to the number of items added to the listbox.
Private Sub cmdClear_Click()
lstName.Clear
lblDisplay.Caption = lstName.ListCount
End Sub
Private Sub cmdExit_Click()
Unload Me
End Sub
Private Sub cmdRemove_Click()
Dim remove As Integer
remove = lstName.ListIndex 'Getting the index
If remove >= 0 Then 'make sure an item is selected
'in the list box
lstName.RemoveItem remove 'Remove item from the list box

lblDisplay.Caption = lstName.ListCount 'Display the number of items

'in the listbox
End If
End Sub
Remove button removes the selected item from the list as soon as you pressed the Remove button. The
number of items is decreased in the listbox and the value is displayed in the label.
The code for the clear button clears the listbox when you press it. And the number of items shown in the
label becomes 0

VB ScrollBar - Using ScrollBar Control In Visual Basic 6 (VB6)

The ScrollBar is a commonly used control, which enables the user to select a value by positioning it at the
desired location. It represents a set of values. The Min and Max property represents the minimum and
maximum value. The value property of the ScrollBar represents its current value, that may be any integer
between minimum and maximum values assigned.
The HScrollBar and the VScrollBar controls are perfectly identical, apart from their different orientation.
After you place an instance of such a control on a form, you have to worry about only a few properties:
Min and Max represent the valid range of values, SmallChange is the variation in value you get when
clicking on the scroll bar's arrows, and LargeChange is the variation you get when you click on either side
of the scroll bar indicator. The default initial value for those two properties is 1, but you'll probably have to
change LargeChange to a higher value. For example, if you have a scroll bar that lets you browse a
portion of text, SmallChange should be 1 (you scroll one line at a time) and LargeChange should be set to
match the number of visible text lines in the window.
The most important run-time property is Value, which always returns the relative position of the indicator
on the scroll bar. By default, the Min value corresponds to the leftmost or upper end of the control:
' Move the indicator near the top (or left) arrow.
VScroll1.Value = VScroll1.Min
' Move the indicator near the bottom (or right) arrow.
VScroll1.Value = VScroll1.Max
While this setting is almost always OK for horizontal scroll bars, you might sometimes need to reverse the
behavior of vertical scroll bars so that the zero is near the bottom of your form. This arrangement is often
desirable if you want to use a vertical scroll bar as a sort of slider. You obtain this behavior by simply
inverting the values in the Min and Max properties. (In other words, it's perfectly legal for Min to be greater
than Max.)
There are two key events for scrollbar controls: the Change event fires when you click on the scroll bar
arrows or when you drag the indicator; the Scroll event fires while you drag the indicator. The reason for
these two distinct possibilities is mostly historical. First versions of Visual Basic supported only the
Change event, and when developers realized that it wasn't possible to have continuous feedback when
users dragged the indicator, Microsoft engineers added a new event instead of extending the Change
event. In this way, old applications could be recompiled without unexpected changes in their behavior. At
any rate, this means that you must often trap two distinct events:
' Show the current scroll bar's value.
Private VScroll1_Change()
Label1.Caption = VScroll1.Value
End Sub
Private VScroll1_Scroll()
Label1.Caption = VScroll1.Value
End Sub
The example shown in the following figure uses three VScrollBar controls as sliders to control the
individual RGB (red, green, blue) components of a color. The three scroll bars have their Min property set
to 255 and their Max property set to 0, while their SmallChange is 1 and LargeChange is 16. This
example is also a moderately useful program in itself because you can select a color and then copy its
numeric value to the clipboard and paste it in your application's code as a decimal value, a hexadecimal
value, or an RGB function.

Use scrollbar controls to visually create colors.

Scrollbar controls can receive the input focus, and in fact they support both the TabIndex and TabStop
properties. If you don't want the user to accidentally move the input focus on a scrollbar control when he
or she presses the Tab key, you must explicitly set its TabStop property to False. When a scrollbar control
has the focus, you can move the indicator using the Left, Right, Up, Down, PgUp, PgDn, Home, and End
keys. For example, you can take advantage of this behavior to create a read-only TextBox control with a
numeric value that can be edited only through a tiny companion scroll bar. This scroll bar appears to the
user as a sort of spin button, as you can see in the figure below. To make the trick work, you need to write
just a few lines of code:
Private Sub Text1_GotFocus()
' Pass the focus to the scroll bar.
VScroll1.SetFocus
End Sub
Private Sub VScroll1_Change()
' Scroll bar controls the text box value.
Text1.Text = VScroll1.Value
End Sub
You don't need external ActiveX controls to create functional spin buttons
Scrollbar controls are even more useful for building scrolling forms, like the one displayed in Figure 3-15.
To be certain, scrolling forms aren't the most ergonomic type of user interface you can offer to your
customers: If you have that many fields in a form, you should consider using a Tab control, child forms, or
some other custom interface. Sometimes, however, you badly need scrollable forms, and in this situation
you are on your own because Visual Basic forms don't support scrolling.
Fortunately, it doesn't take long to convert a regular form into a scrollable one. You need a couple of
scrollbar controls, plus a PictureBox control that you use as the container for all the controls on the form,
and a filler control—a CommandButton, for example—that you place in the bottom-right corner of the form
when it displays the two scroll bars. The secret to creating scrollable forms is that you don't move all the
child controls one by one. Instead, you place all the controls in the PictureBox control (named picCanvas
in the following code), and you move it when the user acts on the scroll bar:
Sub MoveCanvas()
picCanvas.Move -HScroll1.Value, -VScroll1.Value
End Sub
In other words, to uncover the portion of the form near the right border, you assign a negative value to the
PictureBox's Left property, and to display the portion near the form's bottom border you set its Top
property to a negative value. It's really that simple. You do this by calling the MoveCanvas procedure from
within the scroll bars' Change and Scroll events. Of course, it's critical that you write code in the
Form_Resize event, which makes a scroll bar appear and disappear as the form is resized, and that you
assign consistent values to Max properties of the scrollbar controls:
' size of scrollbars in twips
Const SB_WIDTH = 300 ' width of vertical scrollbars
Const SB_HEIGHT = 300 ' height of horizontal scrollbars
Private Sub Form_Resize()
' Resize the scroll bars along the form.
HScroll1.Move 0, ScaleHeight - SB_HEIGHT, ScaleWidth - SB_WIDTH
VScroll1.Move ScaleWidth - SB_WIDTH, 0, SB_WIDTH, _
ScaleHeight - SB_HEIGHT
cmdFiller.Move ScaleWidth - SB_WIDTH, ScaleHeight - SB_HEIGHT, _
SB_WIDTH, SB_HEIGHT
' Put these controls on top.
HScroll1.ZOrder
VScroll1.ZOrder
cmdFiller.ZOrder
picCanvas.BorderStyle = 0
' A click on the arrow moves one pixel.
HScroll1.SmallChange = ScaleX(1, vbPixels, vbTwips)
VScroll1.SmallChange = ScaleY(1, vbPixels, vbTwips)
' A click on the scroll bar moves 16 pixels.
HScroll1.LargeChange = HScroll1.SmallChange * 16
VScroll1.LargeChange = VScroll1.SmallChange * 16
' If the form is larger than the picCanvas picture box,
' we don't need to show the corresponding scroll bar.
If ScaleWidth < picCanvas.Width + SB_WIDTH Then
HScroll1.Visible = True
HScroll1.Max = picCanvas.Width + SB_WIDTH - ScaleWidth
Else
HScroll1.Value = 0
HScroll1.Visible = False
End If
If ScaleHeight < picCanvas.Height + SB_HEIGHT Then
VScroll1.Visible = True
VScroll1.Max = picCanvas.Height + SB_HEIGHT - ScaleHeight
Else
VScroll1.Value = 0
VScroll1.Visible = False
End If
' Make the filler control visible only if necessary.
cmdFiller.Visible = (HScroll1.Visible Or VScroll1.Visible)
MoveCanvas
End Sub
Working with scrollable forms at design time isn't comfortable. I suggest that you work with a maximized
form and with the PictureBox control sized as large as possible. When you're finished with the form
interface, resize the PictureBox control to the smallest area that contains all the controls, and then reset
the form's WindowState property to 0-Normal.

VB ScrollBar - Using ScrollBar Control In Visual Basic 6 (VB6)

The ScrollBar is a commonly used control, which enables the user to select a value by positioning it at the
desired location. It represents a set of values. The Min and Max property represents the minimum and
maximum value. The value property of the ScrollBar represents its current value, that may be any integer
between minimum and maximum values assigned.
The HScrollBar and the VScrollBar controls are perfectly identical, apart from their different orientation.
After you place an instance of such a control on a form, you have to worry about only a few properties:
Min and Max represent the valid range of values, SmallChange is the variation in value you get when
clicking on the scroll bar's arrows, and LargeChange is the variation you get when you click on either side
of the scroll bar indicator. The default initial value for those two properties is 1, but you'll probably have to
change LargeChange to a higher value. For example, if you have a scroll bar that lets you browse a
portion of text, SmallChange should be 1 (you scroll one line at a time) and LargeChange should be set to
match the number of visible text lines in the window.
The most important run-time property is Value, which always returns the relative position of the indicator
on the scroll bar. By default, the Min value corresponds to the leftmost or upper end of the control:
' Move the indicator near the top (or left) arrow.
VScroll1.Value = VScroll1.Min
' Move the indicator near the bottom (or right) arrow.
VScroll1.Value = VScroll1.Max
While this setting is almost always OK for horizontal scroll bars, you might sometimes need to reverse the
behavior of vertical scroll bars so that the zero is near the bottom of your form. This arrangement is often
desirable if you want to use a vertical scroll bar as a sort of slider. You obtain this behavior by simply
inverting the values in the Min and Max properties. (In other words, it's perfectly legal for Min to be greater
than Max.)
There are two key events for scrollbar controls: the Change event fires when you click on the scroll bar
arrows or when you drag the indicator; the Scroll event fires while you drag the indicator. The reason for
these two distinct possibilities is mostly historical. First versions of Visual Basic supported only the
Change event, and when developers realized that it wasn't possible to have continuous feedback when
users dragged the indicator, Microsoft engineers added a new event instead of extending the Change
event. In this way, old applications could be recompiled without unexpected changes in their behavior. At
any rate, this means that you must often trap two distinct events:
' Show the current scroll bar's value.
Private VScroll1_Change()
Label1.Caption = VScroll1.Value
End Sub
Private VScroll1_Scroll()
Label1.Caption = VScroll1.Value
End Sub
The example shown in the following figure uses three VScrollBar controls as sliders to control the
individual RGB (red, green, blue) components of a color. The three scroll bars have their Min property set
to 255 and their Max property set to 0, while their SmallChange is 1 and LargeChange is 16. This
example is also a moderately useful program in itself because you can select a color and then copy its
numeric value to the clipboard and paste it in your application's code as a decimal value, a hexadecimal
value, or an RGB function.

Use scrollbar controls to visually create colors.

Scrollbar controls can receive the input focus, and in fact they support both the TabIndex and TabStop
properties. If you don't want the user to accidentally move the input focus on a scrollbar control when he
or she presses the Tab key, you must explicitly set its TabStop property to False. When a scrollbar control
has the focus, you can move the indicator using the Left, Right, Up, Down, PgUp, PgDn, Home, and End
keys. For example, you can take advantage of this behavior to create a read-only TextBox control with a
numeric value that can be edited only through a tiny companion scroll bar. This scroll bar appears to the
user as a sort of spin button, as you can see in the figure below. To make the trick work, you need to write
just a few lines of code:
Private Sub Text1_GotFocus()
' Pass the focus to the scroll bar.
VScroll1.SetFocus
End Sub
Private Sub VScroll1_Change()
' Scroll bar controls the text box value.
Text1.Text = VScroll1.Value
End Sub
You don't need external ActiveX controls to create functional spin buttons
Scrollbar controls are even more useful for building scrolling forms, like the one displayed in Figure 3-15.
To be certain, scrolling forms aren't the most ergonomic type of user interface you can offer to your
customers: If you have that many fields in a form, you should consider using a Tab control, child forms, or
some other custom interface. Sometimes, however, you badly need scrollable forms, and in this situation
you are on your own because Visual Basic forms don't support scrolling.
Fortunately, it doesn't take long to convert a regular form into a scrollable one. You need a couple of
scrollbar controls, plus a PictureBox control that you use as the container for all the controls on the form,
and a filler control—a CommandButton, for example—that you place in the bottom-right corner of the form
when it displays the two scroll bars. The secret to creating scrollable forms is that you don't move all the
child controls one by one. Instead, you place all the controls in the PictureBox control (named picCanvas
in the following code), and you move it when the user acts on the scroll bar:
Sub MoveCanvas()
picCanvas.Move -HScroll1.Value, -VScroll1.Value
End Sub
In other words, to uncover the portion of the form near the right border, you assign a negative value to the
PictureBox's Left property, and to display the portion near the form's bottom border you set its Top
property to a negative value. It's really that simple. You do this by calling the MoveCanvas procedure from
within the scroll bars' Change and Scroll events. Of course, it's critical that you write code in the
Form_Resize event, which makes a scroll bar appear and disappear as the form is resized, and that you
assign consistent values to Max properties of the scrollbar controls:
' size of scrollbars in twips
Const SB_WIDTH = 300 ' width of vertical scrollbars
Const SB_HEIGHT = 300 ' height of horizontal scrollbars
Private Sub Form_Resize()
' Resize the scroll bars along the form.
HScroll1.Move 0, ScaleHeight - SB_HEIGHT, ScaleWidth - SB_WIDTH
VScroll1.Move ScaleWidth - SB_WIDTH, 0, SB_WIDTH, _
ScaleHeight - SB_HEIGHT
cmdFiller.Move ScaleWidth - SB_WIDTH, ScaleHeight - SB_HEIGHT, _
SB_WIDTH, SB_HEIGHT
' Put these controls on top.
HScroll1.ZOrder
VScroll1.ZOrder
cmdFiller.ZOrder
picCanvas.BorderStyle = 0
' A click on the arrow moves one pixel.
HScroll1.SmallChange = ScaleX(1, vbPixels, vbTwips)
VScroll1.SmallChange = ScaleY(1, vbPixels, vbTwips)
' A click on the scroll bar moves 16 pixels.
HScroll1.LargeChange = HScroll1.SmallChange * 16
VScroll1.LargeChange = VScroll1.SmallChange * 16
' If the form is larger than the picCanvas picture box,
' we don't need to show the corresponding scroll bar.
If ScaleWidth < picCanvas.Width + SB_WIDTH Then
HScroll1.Visible = True
HScroll1.Max = picCanvas.Width + SB_WIDTH - ScaleWidth
Else
HScroll1.Value = 0
HScroll1.Visible = False
End If
If ScaleHeight < picCanvas.Height + SB_HEIGHT Then
VScroll1.Visible = True
VScroll1.Max = picCanvas.Height + SB_HEIGHT - ScaleHeight
Else
VScroll1.Value = 0
VScroll1.Visible = False
End If
' Make the filler control visible only if necessary.
cmdFiller.Visible = (HScroll1.Visible Or VScroll1.Visible)
MoveCanvas
End Sub
Working with scrollable forms at design time isn't comfortable. I suggest that you work with a maximized
form and with the PictureBox control sized as large as possible. When you're finished with the form
interface, resize the PictureBox control to the smallest area that contains all the controls, and then reset
the form's WindowState property to 0-Normal.

Control Arrays in Visual Basic 6

A control array is a group of controls that share the same name type and the same event procedures.
Adding controls with control arrays uses fewer resources than adding multiple control of same type at
design time.
A control array can be created only at design time, and at the very minimum at least one control must
belong to it. You create a control array following one of these three methods:
• You create a control and then assign a numeric, non-negative value to its Index property; you
have thus created a control array with just one element.
• You create two controls of the same class and assign them an identical Name property. Visual
Basic shows a dialog box warning you that there's already a control with that name and asks whether you
want to create a control array. Click on the Yes button.
• You select a control on the form, press Ctrl+C to copy it to the clipboard, and then press Ctrl+V to
paste a new instance of the control, which has the same Name property as the original one. Visual Basic
shows the warning mentioned in the previous bullet.
Control arrays are one of the most interesting features of the Visual Basic environment, and they add a lot
of flexibility to your programs:
• Controls that belong to the same control array share the same set of event procedures; this often
dramatically reduces the amount of code you have to write to respond to a user's actions.
• You can dynamically add new elements to a control array at run time; in other words, you can
effectively create new controls that didn't exist at design time.
• Elements of control arrays consume fewer resources than regular controls and tend to produce
smaller executables. Besides, Visual Basic forms can host up to 256 different control names, but a control
array counts as one against this number. In other words, control arrays let you effectively overcome this
limit.
The importance of using control arrays as a means of dynamically creating new controls at run time is
somewhat reduced in Visual Basic 6, which has introduced a new and more powerful capability.
Don't let the term array lead you to think control array is related to VBA arrays; they're completely different
objects. Control arrays can only be one-dimensional. They don't need to be dimensioned: Each control
you add automatically extends the array. The Index property identifies the position of each control in the
control array it belongs to, but it's possible for a control array to have holes in the index sequence. The
lowest possible value for the Index property is 0. You reference a control belonging to a control array as
you would reference a standard array item:
Text1(0).Text = ""

Sharing Event Procedures

Event procedures related to items in a control array are easily recognizable because they have an extra
Index parameter, which precedes all other parameters. This extra parameter receives the index of the
element that's raising the event, as you can see in this example:
Private Sub Text1_KeyPress(Index As Integer, KeyAscii As Integer)
MsgBox "A key has been pressed on Text1(" & Index & ") control"
End Sub
The fact that multiple controls can share the same set of event procedures is often in itself a good reason
to create a control array. For example, say that you want to change the background color of each of your
TextBox controls to yellow when it receives the input focus and restore its background color to white when
the user clicks on another field:
Private Sub Text1_GotFocus(Index As Integer)
Text1(Index).BackColor = vbYellow
End Sub
Private Sub Text1_LostFocus(Index As Integer)
Text1(Index).BackColor = vbWhite
End Sub
Control arrays are especially useful with groups of OptionButton controls because you can remember
which element in the group has been activated by adding one line of code to their shared Click event.
This saves code when the program needs to determine which button is the active one:
' A module-level variable
Dim optFrequencyIndex As Integer
Private Sub optFrequency_Click(Index As Integer)
' Remember the last button selected.
optFrequencyIndex = Index
End Sub

Creating Controls at Run Time

Control arrays can be created at run time using the statements
• Load object (Index %)
• Unload object (Index %)
Where object is the name of the control to add or delete from the control array. Index % is the value of the
index in the array. The control array to be added must be an element of the existing array created at
design time with an index value of 0. When a new element of a control array is loaded, most of the
property settings are copied from the lowest existing element in the array.
Following example illustrates the use of the control array.
* Open a Standard EXE project and save the Form as Calculator.frm and save the Project as
Calculater.vbp.
* Design the form as shown below.
Object Property Setting
 Caption Calculator
Form
Name frmCalculator

Caption 1
CommandButto
Name cmd
n
Index 0

Caption 2
CommandButto
Name cmd
n
Index 1

Caption 3
CommandButto
Name cmd
n
Index 2

Caption 4
CommandButto
Name cmd
n
Index 3

Caption 5
CommandButto
Name cmd
n
Index 4

Caption 6
CommandButto
Name cmd
n
Index 5

Caption 7
CommandButto
Name cmd
n
Index 6

Caption 8
CommandButto
Name cmd
n
Index 7

Caption 9
CommandButto
Name cmd
n
Index 8

Caption 0
CommandButto
Name cmd
n
Index 10
CommandButto Caption .
 Name
n cmd
Index
11

CommandButto Caption AC
n Name cmdAC

CommandButto Caption +
n Name cmdPlus

CommandButto Caption -
n Name cmdMinus

CommandButto Caption *
n Name cmdMultiply

CommandButto Caption /
n Name cmdDivide

CommandButto Caption +/-

n Name cmdNeg

Name txtDisplay
TextBox
Text ( empty )

CommandButto Caption =
n Name cmdEqual

The following variables are declared inside the general declaration

Dim Current As Double
Dim Previous As Double
Dim Choice As String
Dim Result As Double
The following code is entered in the cmd_Click( ) (Control Array) event procedure
Private Sub cmd_Click(Index As Integer)
txtDisplay.Text = txtDisplay.Text & cmd(Index).Caption
'&is the concatenation operator
Current = Val(txtDisplay.Text)
End Sub
The following code is entered in the cmdAC_Click ( ) event procedure
Private Sub cmdAC_Click()
Current = Previous = 0
txtDisplay.Text = ""
End Sub
The below code is entered in the cmdNeg_Click( ) procedure
Private Sub cmdNeg_Click()
Current = -Current
txtDisplay.Text = Current
End Sub
The following code is entered in the click events of the cmdPlus, cmdMinus, cmdMultiply, cmdDevide
controls respectively.
Private Sub cmdDevide_Click()
txtDisplay.Text = ""
Previous = Current
Current = 0
Choice = "/"
End Sub
Private Sub cmdMinus_Click()
txtDisplay.Text = ""
Previous = Current
Current = 0
Choice = "-"
End Sub
Private Sub cmdMultiply_Click()
txtDisplay.Text = ""
Previous = Current
Current = 0
Choice = "*"
End Sub
Private Sub cmdPlus_Click()
txtDisplay.Text = ""
Previous = Current
Current = 0
Choice = "+"
End Sub
To print the result on the text box, the following code is entered in the cmdEqual_Click ( ) event
procedure.
Private Sub cmdEqual_Click()
Select Case Choice

Case "+"
Result = Previous + Current
txtDisplay.Text = Result
Case "-"
Result = Previous - Current
txtDisplay.Text = Result
Case "*"
Result = Previous * Current
txtDisplay.Text = Result
Case "/"
Result = Previous / Current
txtDisplay.Text = Result
End Select

Current = Result

End Sub
Save and run the project. On clicking digits of user's choice and an operator button, the output appears.
Iterating on the Items of a Control Array
Control arrays often let you save many lines of code because you can execute the same statement, or
group of statements, for every control in the array without having to duplicate the code for each distinct
control. For example, you can clear the contents of all the items in an array of TextBox controls as
follows:
For i = txtFields.LBound To txtFields.UBound
txtFields(i).Text = ""
Next
Here you're using the LBound and UBound methods exposed by the control array object, which is an
intermediate object used by Visual Basic to gather all the controls in the array. In general, you shouldn't
use this approach to iterate over all the items in the array because if the array has holes in the Index
sequence an error will be raised. A better way to loop over all the items of a control array is using the For
Each statement:
Dim txt As TextBox
For Each txt In txtFields
txt.Text = ""
Next
A third method exposed by the control array object, Count, returns the number of elements it contains. It
can be useful on several occasions (for example, when removing all the controls that were added
dynamically at run time):
' This code assumes that txtField(0) is the only control that was
' created at design time (you can't unload it at run time).
Do While txtFields.Count > 1
Unload txtFields(txtFields.UBound)
Loop

Arrays of Menu Items

Control arrays are especially useful with menus because arrays offer a solution to the proliferation of
menu Click events and, above all, permit you to create new menus at run time. An array of menu controls
is conceptually similar to a regular control array, only you set the Index property to a numeric (non-
negative) value in the Menu Editor instead of in the Properties window.
There are some limitations, though: All the items in an array of menu controls must be adjacent and must
belong to the same menu level, and their Index properties must be in ascending order (even though holes
in the sequence are allowed). This set of requirements severely hinders your ability to create new menu
items at run time. In fact, you can create new menu items in well-defined positions of your menu hierarchy
—namely, where you put a menu item with a nonzero Index value—but you can't create new submenus
or new top-level menus.
Now that you have a thorough understanding of how Visual Basic's forms and controls work, you're ready
to dive into the subtleties of the Visual Basic for Applications (VBA) language.
DriveListBox, DirListBox, and FileListBox Controls in Visual Basic
6

Three of the controls on the ToolBox let you access the computer's file system. They are DriveListBox,
DirListBox and FileListBox controls (see below figure) , which are the basic blocks for building dialog
boxes that display the host computer's file system. Using these controls, user can traverse the host
computer's file system, locate any folder or files on any hard disk, even on network drives. The files are
controls are independent of one another, and each can exist on it's own, but they are rarely used
separately. The files controls are described next.
In a nutshell, the DriveListBox control is a combobox-like control that's automatically filled with your
drive's letters and volume labels. The DirListBox is a special list box that displays a directory tree. The
FileListBox control is a special-purpose ListBox control that displays all the files in a given directory,
optionally filtering them based on their names, extensions, and attributes.
These controls often work together on the same form; when the user selects a drive in a DriveListBox, the
DirListBox control is updated to show the directory tree on that drive. When the user selects a path in the
DirListBox control, the FileListBox control is filled with the list of files in that directory. These actions don't
happen automatically, however—you must write code to get the job done.
After you place a DriveListBox and a DirListBox control on a form's surface, you usually don't have to set
any of their properties; in fact, these controls don't expose any special property, not in the Properties
window at least. The FileListBox control, on the other hand, exposes one property that you can set at
design time—the Pattern property. This property indicates which files are to be shown in the list area: Its
default value is *.* (all files), but you can enter whatever specification you need, and you can also enter
multiple specifications using the semicolon as a separator. You can also set this property at run time, as
in the following line of code:
File1.Pattern = "*.txt;*.doc;*.rtf"
Following figure shows three files controls are used in the design of Forms that let users explore the
entire structure of their hard disks.
• DriveListBox : Displays the names of the drives within and connected to the PC. The basic
property of this control is the drive property, which set the drive to be initially selected in the control or
returns the user's selection.
• DirListBox : Displays the folders of current Drive. The basic property of this control is the Path
property, which is the name of the folder whose sub folders are displayed in the control.
• FileListBox : Displays the files of the current folder. The basic property of this control is also
called Path, and it's the path name of the folder whose files are displayed.
The three File controls are not tied to one another. If you place all three of them on a Form, you will see
the names of all the folders under the current folder, and so on. Each time you select a folder in the
DirlistBox by double clicking its name, its sub folders are displayed. Similarly , the FileListBox control will
display the names of all files in the current folder. Selecting a drive in the DriveListBox control, however
this doesn't affect the contents of the DirListBox.
To connect to the File controls, you must assign the appropriate values to the properties. To compel the
DirListBox to display the folders of the selected drive in the DriveListBox, you must make sure that each
time the user selects another drive, the Path property of the DirListBox control matches the Drive property
of the DriveListBox.
After these preliminary steps, you're ready to set in motion the chain of events. When the user selects a
new drive in the DriveListBox control, it fires a Change event and returns the drive letter (and volume
label) in its Drive property. You trap this event and set the DirListBox control's Path property to point to
the root directory of the selected drive:
Private Sub Drive1_Change()
' The Drive property also returns the volume label, so trim it.
Dir1.Path = Left$(Drive1.Drive, 1) & ":\"
End Sub
When the user double-clicks on a directory name, the DirListBox control raises a Change event; you trap
this event to set the FileListBox's Path property accordingly:
Private Sub Dir1_Change()
File1.Path = Dir1.Path
End Sub
Finally, when the user clicks on a file in the FileListBox control, a Click event is fired (as if it were a regular
ListBox control), and you can query its Filename property to learn which file has been selected. Note how
you build the complete path:
Filename = File1.Path
If Right$(Filename, 1) <> "\" Then Filename = Filename & "\"
Filename = Filename & File1.Filename
The DirListBox and FileListBox controls support most of the properties typical of the control they derive
from—the ListBox control—including the ListCount and the ListIndex properties and the Scroll event. The
FileListBox control supports multiple selection; hence you can set its MultiSelect property in the
Properties window and query the SelCount and Selected properties at run time.
The FileListBox control also exposes a few custom Boolean properties, Normal, Archive, Hidden,
ReadOnly, and System, which permit you to decide whether files with these attributes should be listed.
(By default, the control doesn't display hidden and system files.) This control also supports a couple of
custom events, PathChange and PatternChange, that fire when the corresponding property is changed
through code. In most cases, you don't have to worry about them, and I won't provide examples of their
usage.
The problem with the DriveListBox, DirListBox and FileListBox controls is that they're somewhat outdated
and aren't used by most commercial applications any longer. Moreover, these controls are known to work
incorrectly when listing files on network servers and sometimes even on local disk drives, especially when
long file and directory names are used. For this reason, I discourage you from using them and suggest
instead that you use the Common Dialog controls for your FileOpen and FileSave dialog boxes. But if you
need to ask the user for the name of a directory rather than a file, you're out of luck because—while
Windows does include such a system dialog box, named BrowseForFolders dialog—Visual Basic still
doesn't offer a way to display it (unless you do some advanced API programming). Fortunately, Visual
Basic 6 comes with a new control—the ImageCombo control—that lets you simulate the appearance of
the DriveListBox control. It also offers you a powerful library—the FileSystemObject library—that
completely frees you from using these three controls, if only as hidden controls that you use just for
quickly retrieving information on the file system.

Using a CheckBox control in Visual Basic 6

The CheckBox control is similar to the option button, except that a list of choices can be made
using check boxes where you cannot choose more than one selection using an OptionButton. By
ticking the CheckBox the value is set to True. This control can also be grayed when the state of the
CheckBox is unavailable, but you must manage that state through code.
When you place a CheckBox control on a form, all you have to do, usually, is set its Caption property to a
descriptive string. You might sometimes want to move the little check box to the right of its caption, which
you do by setting the Alignment property to 1-Right Justify, but in most cases the default setting is OK. If
you want to display the control in a checked state, you set its Value property to 1-Checked right in the
Properties window, and you set a grayed state with 2-Grayed.
The only important event for CheckBox controls is the Click event, which fires when either the user or the
code changes the state of the control. In many cases, you don't need to write code to handle this event.
Instead, you just query the control's Value property when your code needs to process user choices. You
usually write code in a CheckBox control's Click event when it affects the state of other controls. For
example, if the user clears a check box, you might need to disable one or more controls on the form and
reenable them when the user clicks on the check box again. This is how you usually do it (here I grouped
all the relevant controls in one frame named Frame1):
Private Sub Check1_Click()
Frame1.Enabled = (Check1.Value = vbChecked)
End Sub
Note that Value is the default property for CheckBox controls, so you can omit it in code. I suggest that
you not do that, however, because it would reduce the readability of your code.
The following example illustrates the use of CheckBox control
* Open a new Project and save the Form as CheckBox.frm and save the Project as CheckBox.vbp
* Design the Form as shown below

Object Property Setting

Form Caption CheckBox
 Name frmCheckBox

Caption Bold
CheckBox
Name chkBold

Caption Italic
CheckBox
Name chkItalic

Caption Underline
CheckBox
Name chkUnderline

Caption Red
OptionButton
Name optRed

Caption Blue
OptionButton
Name optBlue

Caption Green
OptionButton
Name optGreen

Name txtDisplay
TextBox
Text (empty)

Caption Exit
CommandButton
Name cmdExit

Following code is typed in the Click() events of the CheckBoxes

Private Sub chkBold_Click()
If chkBold.Value = 1 Then
txtDisplay.FontBold = True
Else
txtDisplay.FontBold = False
End If
End Sub
Private Sub chkItalic_Click()
If chkItalic.Value = 1 Then
txtDisplay.FontItalic = True
Else
txtDisplay.FontItalic = False
End If
End Sub
Private Sub chkUnderline_Click()
If chkUnderline.Value = 1 Then
txtDisplay.FontUnderline = True
Else
txtDisplay.FontUnderline = False
End If
End Sub
Following code is typed in the Click() events of the OptionButtons
Private Sub optBlue_Click()
txtDisplay.ForeColor = vbBlue
End Sub
Private Sub optRed_Click()
txtDisplay.ForeColor = vbRed
End Sub
Private Sub optGreen_Click()
txtDisplay.ForeColor = vbGreen
End Sub
To terminate the program following code is typed in the Click() event of the Exit button
Private Sub cmdExit_Click()
End
End Sub
Run the program by pressing F5. Check the program by clicking on OptionButtons and CheckBoxes.

Working with Forms in Visual Basic 6

The Appearance of Forms
The main characteristic of a Form is the title bar on which the Form's caption is displayed. On the left end
of the title bar is the Control Menu icon. Clicking this icon opens the Control Menu. Maximize, Minimize
and Close buttons can be found on the right side of the Form. Clicking on these buttons performs the
associated function.
The following figure illustrates the appearance of a Form
The control menu contains the following commands :
• Restore : Restores a maximized Form to the size it was before it was maximized; available only if
the Form has been maximized.
• Move : Lets the user moves the Form around with the mouse
• Size : Lets the user resizes the control with the mouse
• Minimize: Minimizes the Form
• Maximize : Maximizes the Form
• Close : Closes the Form
Setting the Start-Up Form
A typical application has more than a single Form. When an application runs the main Form is loaded. By
setting the Project properties you can control which Form is to be displayed in the Start-Up of the
application. Following figure illustrates the Project property window.

By default, Visual Basic suggests the name of the first Form created when the project started.
Loading and Unloading Forms
In order to load and unload the forms, Load and Unload statements are used. The Load statement has
the following syntax :
Load FormName
And the Unload statement has the following syntax :
Unload FormName
The FormName variable is the name of the Form to be loaded or unloaded. Unlike the Show method
which cares of both loading and displaying the Form, the load statement doesn't show the Form. You
have to call the Form's Show method to display it on the desktop.
Showing and Hiding Forms
Show method is used to Show a Form. If the Form is loaded but invisible, the Show method is used to
bring the Form on Top every other window. If the Form is not loaded, the Show method loads it and then
displays it.
Syntax of the Show method of the Form
FormName.Show mode
The FormName variable is the Form's name, and the optional argument mode determines whether the
Form will be Modal or not. It can have one of the following syntax :

* 0-Modeless (default)
* 1-Modal
Modeless Forms are the normal Forms. Modeless Forms interact with the user and the user allowed to
switch to any other Form of the application. If you do not specify the optional mode argument, by default
the mode is set to modeless.
The Modal Forms takes the total control of the application where user cannot switch to any other Forms in
the application unless the Form is closed. A modal Form, thus, must have a Close button or some means
to close the Form in order to return to the Form where the Modal Form was loaded.
Hiding Forms
The Hide method is used to hide a Form. The following is the syntax of the Hide Method.
FormName.Hide
To hide a Form from within its own code, the following code can be used.
Me.Hide
You must understand that the Forms that are hidden are not unloaded ; they remains in the memory and
can be displayed instantly with the Show Method. When a Form is hidden, you can still access its
properties and code. For instance, you can change the settings of its Control Properties or call any Public
functions in the Form.
The following is an example illustrates the Show method and Mode statement
* Open a new Project and save the Project
Design the application as shown below

Object Property Setting

Caption Form1
Form
Name frm1

Caption Form2
Form
Name frm2

Caption Form3
Form
Name frm3

Click on a button
Caption
Label to display a Form
Name
Label1

The following code is typed in the Click event of the command buttons
Run the application. Clicking on the buttons will display the Forms respectively. But you can see that in
the cmd2_Click( ) event additionally VbModal argument has been added. You can see the difference after
you display the forms by clicking on the command buttons. You can notice that you cannot switch to any
other Forms in the application unless you close the Form3. (Download the source code)
Finding out the difference between Unload and Hide method
To know what the difference is between Unload and Hide methods we will do an example. Open a new
project and save the project. Draw two buttons on the form and name those as shown above.

In the click event of the Hide button Following code is entered.

Me.Hide
In the click event of the Unload button following code is entered.
Unload Me
Save the project and run the application. Once you click on Hide button you can note that the Form is
invisible but the application is still running. But when you click on Unload button you can see that the
application is terminated.

Working with Menus in Visual Basic 6 (VB6)

Windows applications provide groups of related commands in Menus. These commands depends on the
application, but some-such as Open and Save are frequently found in applications. Menus are intrinsic
controls, and as such they deserve a place in this chapter. On the other hand, menus behave differently
from other controls. For example, you don't drop menu items on a form from the Toolbox; rather, you
design them in the Menu Editor window, as you can see in the figur below. You invoke this tool from the
Menu Editor button on the standard toolbar or by pressing the Ctrl+E shortcut key. There's also a Menu
Editor command in the Tools menu, but you probably won't use it often.
Visual Basic provides an easy way to create menus with the modal Menu Editor dialog. The below dialog
is displayed when the Menu Editor is selected in the Tool Menu. The Menu Editor command is grayed
unless the form is visible. And also you can display the Menu Editor window by right clicking on the Form
and selecting Menu Editor.
Basically, each menu item has a Caption property (possibly with an embedded & character to create an
access key) and a Name. Each item also exposes three Boolean properties, Enabled, Visible, and
Checked, which you can set both at design time and at run time. At design time, you can assign the menu
item a shortcut key so that your end users don't have to go through the menu system each time they want
to execute a frequent command. (Do you really like pulling down the Edit menu any time you need to
clear some text or copy it to the Clipboard?) The assigned shortcut key can't be queried at run time, much
less modified.
Building a menu is a simple, albeit more tedious, job: You enter the item's Caption and Name, set other
properties (or accept the default values for those properties), and press Enter to move to the next item.
When you want to create a submenu, you press the Right Arrow button (or the Alt+R hot key). When you
want to return to work on top-level menus—those items that appear in the menu bar when the application
runs—you click the Left Arrow button (or press Alt+L). You can move items up and down in the hierarchy
by clicking the corresponding buttons or the hot keys Alt+U and Alt+B, respectively.
You can create up to five levels of submenus (six including the menu bar), which are too many even for
the most patient user. If you find yourself working with more than three menu levels, think about trashing
your specifications and redesigning your application from the ground up.
You can insert a separator bar using the hypen (-) character for the Caption property. But even these
separator items must be assigned a unique value for the Name property, which is a real nuisance. If you
forget to enter a menu item's Name, the Menu Editor complains when you decide to close it. The
convention used in this book is that all menu names begin with the three letters mnu.
An expanded Menu Editor window.

An expanded menu

One of the most annoying defects of the Menu Editor tool is that it doesn't permit you to reuse the menus
you have already written in other applications. It would be great if you could open another instance of the
Visual Basic IDE, copy one or more menu items to the clipboard, and then paste those menu items in the
application under development. You can do that with controls and with pieces of code, but not with
menus! The best thing you can do in Visual Basic is load the FRM file using an editor such as Notepad,
find the portion in the file that corresponds to the menu you're interested in, load the FRM file you're
developing (still in Notepad), and paste the code there. This isn't the easiest operation, and it's also
moderately dangerous: If you paste the menu definition in the wrong place, you could make your FRM
form completely unreadable. Therefore, always remember to make backup copies of your forms before
trying this operation.
Better news is that you can add a finished menu to a form in your application with just a few mouse clicks.
All you have to do is activate the Add-In Manager from the Add-Ins menu, choose the VB 6 Template
Manager, and tick the Loaded/Unloaded check box. After you do that, you'll find three new commands in
the Tools menu: Add Code Snippet, Add Menu, and Add Control Set. Visual Basic 6 comes with a few
menu templates, as you can see in the following figure, that you might find useful as a starting point for
building your own templates. To create your menu templates, you only have to create a form with the
complete menu and all the related code and then store this form in the \Templates\Menus directory. (The
complete path, typically c:\Program Files\Microsoft Visual Studio\VB98\Template, can be found in the
Environment tab of the Options dialog box on the Tools menu. The Template Manager was already
available with Visual Basic 5, but it had to be installed manually and relatively few programmers were
aware of its existence.

The Template Manager in action

The programmer can create menu control arrays. The Index TextBox specifies the menu's index in the
control array.
The Menu Editor dialog also provides several CheckBoxes to control the appearance of the Menu.
Checked : This is unchecked by default and allows the programmer the option of creating a checked
menu item( a menu item that act as a toggle and displays a check mark when selected. The following is a
Check Menu items.

Enabled : specifies whether a menu is disabled or not. If you see a disabled command in a menu that
means that feature is not available. The Visible checkbox specifies whether the menu is visible or not.
To add commands to the Form's menu bar, enter a caption and a name for each command. As soon as
you start typing the command's caption, it also appears in a new line in the list at the bottom of the Menu
Editor window. To add more commands click Enter and type the Caption and the Name.
Creating Menus
Open a new Project and save the form as menu.frm and save the project as menu.vbp.
Choose Tools ››› Menu Editor and type the menu items as shown below.
Caption Name
File mnuFile
Open mnuOpen
Save mnuSave
Exit mnuExit
Edit mnuEdit
Copy mnuCopy
Cut mnuCut
Paste mnuPaste

Run the application by pressing F5. You can see that you can select a men.

Accessing Menus at Run Time in Visual Basic 6

Menu controls expose only one event, Click. As you expect, this event fires when the user clicks on the
menu:
Private Sub mnuFileExit_Click()
Unload Me
End Sub
You can manipulate menu items at run time through their Checked, Visible, and Enabled properties. For
example, you can easily implement a menu item that acts as a switch and displays or hides a status bar:
Private Sub mnuViewStatus_Click()
' First, add or remove the check sign.
mnuViewStatus.Checked = Not mnuViewStatus.Checked
' Then make the status bar visible or not.
staStatusBar.Visible = mnuViewStatus.Checked
End Sub
While menu items can be responsible for their own Checked status, you usually set their Visible and
Enabled properties in another region of the code. You make a menu item invisible or disabled when you
want to make the corresponding command unavailable to the user. You can choose from two different
strategies to achieve this goal: You can set the menu properties as soon as something happens that
affects that menu command, or you can set them one instant before the menu is dropped down. Let me
explain these strategies with two examples.
Let's say that the Save command from the File menu should look disabled if your application has loaded a
read-only file. In this case, the most obvious place in code to set the menu Enabled property to False is in
the procedure that loads the file, as shown in the code below.
Private Sub LoadDataFile(filename As String)
' Load the file in the program.
' ... (code omitted)...
' Enable or disable the menu enabled state according to the file's
' read-only attribute (no need for an If...Else block).
mnuFileSave.Enabled = (GetAttr(filename) And vbReadOnly)
End Sub
This solution makes sense because the menu state doesn't change often. By comparison, the state of
most of the commands in a typical Edit menu (Copy, Cut, Clear, Undo, and so on) depends on whether
any text is currently selected in the active control. In this case, changing the menu state any time a
condition changes (because the user selects or deselects text in the active control, for example) is a
waste of time, and it also requires a lot of code. Therefore, it's preferable to set the state of those menu
commands in the parent menu's Click event just before displaying the menu:
Private Sub mnuEdit_Click()
' The user has clicked on the Edit menu,
' but the menu hasn't dropped down yet.
On Error Resume Next
' Error handling is necessary because we don't know if
' the Active control actually supports these properties.
mnuEditCopy.Enabled = (ActiveControl.SelText <> "")
mnuEditCut.Enabled = (ActiveControl.SelText <> "")
mnuEditClear.Enabled = (ActiveControl.SelText <> "")
End Sub

Creating Pop-up Menus in Visual Basic 6

Visual Basic also supports pop-up menus, those context-sensitive menus that most commercial
applications show when you right-click on an user interface object. In Visual Basic, you can display a pop-
up menu by calling the form's PopupMenu method, typically from within the MouseDown event procedure
of the object:
Private Sub List1_MouseDown(Button As Integer, Shift As Integer, _
X As Single, Y As Single)
If Button And vbRightButton Then
' User right-clicked the list box.
PopupMenu mnuListPopup
End If
End Sub
The argument you pass to the PopupMenu method is the name of a menu that you have defined using
the Menu Editor. This might be either a submenu that you can reach using the regular menu structure or a
submenu that's intended to work only as a pop-up menu. In the latter case, you should create it as a top-
level menu in the Menu Editor and then set its Visible attribute to False. If your program includes many
pop-up menus, you might find it convenient to add one invisible top-level entry and then add all the pop-
up menus below it. (In this case, you don't need to make each individual item invisible.) The complete
syntax of the PopupMenu method is quite complex:
PopupMenu Menu, [Flags], [X], [Y], [DefaultMenu]
By default, pop-up menus appear left aligned on the mouse cursor, and even if you use a right-click to
invoke the menu you can select a command only with the left button. You can change these defaults
using the Flags argument. The following constants control the alignment: 0-vbPopupMenuLeftAlign
(default), 4-vbPopupMenuCenterAlign, and 8-vbPopupMenuRightAlign. The following constants
determine which buttons are active during menu operations: 0-vbPopupMenuLeftButton (default) and 2-
vbPopupMenuRightButton. For example, I always use the latter because I find it natural to select a
command with the right button since it's already pressed when the menu appears:
PopupMenu mnuListPopup, vbPopupMenuRightButton
The x and y arguments, if specified, make the menu appear in a particular position on the form, rather
than at mouse coordinates. The last optional argument is the name of the menu that's the default item for
the pop-up menu. This item will be displayed in boldface. This argument has only a visual effect; If you
want to offer a default menu item, you must write code in the MouseDown event procedure to trap double-
clicks with the right button.
You can take advantage of the x and y arguments in a PopupMenu method to make your program more
Windows compliant, and show your pop-up menus over the control that has the focus when the user
presses the Application key (the key beside the Windows key on the right side of a typical extended
keyboard, such as the Microsoft Natural Keyboard). But remember that Visual Basic doesn't define any
key-code constant for this key. Here's how you must proceed:
Private Sub List1_KeyDown(KeyCode As Integer, Shift As Integer)
If KeyCode = 93 Then
' The system pop-up menu key has been pressed.
' Show a pop-up menu near the list box's center.
PopupMenu mnuListPopup, , List1.Left + _
List1.Width / 2, List1.Top + List1.Height / 2
End If
End Sub
Visual Basic's implementation of pop-up menus has a serious flaw. All Visual Basic TextBox controls
react to right-clicks by showing the standard Edit pop-up menu (with the usual commands, such as Undo,
Copy, Cut, and so on). The problem is that if you invoke a PopupMenu method from within the TextBox
control's MouseDown event, your custom pop-up menu will be displayed only after the standard one,
which is obviously undesirable. You can solve it only by resorting to the unorthodox and undocumented
technique shown below.
Private Sub Text1_MouseDown(Button As Integer, _
Shift As Integer, X As Single, Y As Single)
If Button And vbRightButton Then
Text1.Enabled = False
PopupMenu mnuMyPopup
Text1.Enabled = True
End If
End Sub

The Multiple Document Interface (MDI) in Visual Basic 6

The Multiple Document Interface (MDI) was designed to simplify the exchange of information among
documents, all under the same roof. With the main application, you can maintain multiple open windows,
but not multiple copies of the application. Data exchange is easier when you can view and compare many
documents simultaneously.
You almost certainly use Windows applications that can open multiple documents at the same time and
allow the user to switch among them with a mouse-click. Multiple Word is a typical example, although
most people use it in single document mode. Each document is displayed in its own window, and all
document windows have the same behavior. The main Form, or MDI Form, isn't duplicated, but it acts as
a container for all the windows, and it is called the parent window. The windows in which the individual
documents are displayed are called Child windows.
An MDI application must have at least two Form, the parent Form and one or more child Forms. Each of
these Forms has certain properties. There can be many child forms contained within the parent Form, but
there can be only one parent Form.
The parent Form may not contain any controls. While the parent Form is open in design mode, the icons
on the ToolBox are not displayed, but you can't place any controls on the Form. The parent Form can,
and usually has its own menu.
To create an MDI application, follow these steps:
1. Start a new project and then choose Project >>> Add MDI Form to add the parent Form.
2. Set the Form's caption to MDI Window
3. Choose Project >>> Add Form to add a SDI Form.
4. Make this Form as child of MDI Form by setting the MDI Child property of the SDI Form
to True. Set the caption property to MDI Child window.
Visual Basic automatically associates this new Form with the parent Form. This child Form can't exist
outside the parent Form; in the words, it can only be opened within the parent Form.
 Parent and Child Menus
MDI Form cannot contain objects other than child Forms, but MDI Forms can have their own menus.
However, because most of the operations of the application have meaning only if there is at least one
child Form open, there's a peculiarity about the MDI Forms. The MDI Form usually has a menu with two
commands to load a new child Form and to quit the application. The child Form can have any number of
commands in its menu, according to the application. When the child Form is loaded, the child Form's
menu replaces the original menu on the MDI Form
Following example illustrates the above explanation.
* Open a new Project and name the Form as Menu.frm and save the Project as Menu.vbp
* Design a menu that has the following structure.
<> MDIMenu Menu caption
• MDIOpen opens a new child Form
• MDIExit terminates the application
* Then design the following menu for the child Form
<> ChildMenu Menu caption
• Child Open opens a new child Form
• Child Save saves the document in the active child Form
• Child Close Closes the active child Form
At design time double click on MDI Open and add the following code in the click event of the open menu.
Form1.Show
And so double click on MDI Exit and add the following code in the click event
End
Double click on Child Close and enter the following code in the click event
Unload Me
Before run the application in the project properties set MDI Form as the start-up Form. Save and run the
application. Following output will be displayed.
And as soon as you click MDI Open you can notice that the main menu of the MDI Form is replaced with
the Menu of the Child Form. The reason for this behavior should be obvious. The operation available
through the MDI Form are quite different from the operations of the child window. Moreover, each child
Form shouldn't have it's own menu.

InputBox Function in Visual Basic 6 (VB6)

Displays a prompt in a dialog box, waits for the user to input text or click a button, and returns a String
containing the contents of the text box.
Following is an expanded InputBox

Syntax :
memory_variable = InputBox (prompt[,title][,default])
memory_variable is a variant data type but typically it is declared as string, which accept the message
input by the users. The arguments are explained as follows:
• Prompt - String expression displayed as the message in the dialog box. If prompt consists of
more than one line, you can separate the lines using the vbCrLf constant
• Title - String expression displayed in the title bar of the dialog box. If you omit the title, the
application name is displayed in the title bar
• default-text - The default text that appears in the input field where users can use it as his
intended input or he may change to the message he wish to key in.
• x-position and y-position - the position or the coordinate of the input box.
Following example demonstrates the use of InputBox function

* Open a new project and save the Form as InputBox.frm and save the Project as InputBox.vbp
* Design the application as shown below.

Object Property Setting

Form Caption InputBox test

Name frmInputBox
Label Caption You entered
Name lbl1

Caption ( empty)
Label
Name lbl2
BorderStyle 1-Fixed Single

CommandButton Caption OK
Name cmdOK

Following code is entered in cmdOK_Click ( ) event

Private Sub cmdok_Click()
Dim ans As String
ans = InputBox("Enter something to be displayed in the label", "Testing", 0)
If ans = "" Then
lbl2.Caption = "No message"
Else
lbl2.Caption = ans
End If
End Sub
Save and run the application. As soon as you click the OK button you will get the following InputBox

Here I have entered "Hello World" in text field. As soon as you click OK the output is shown as shown
below
MessageBox Function in Visual Basic 6 (VB6)
Displays a message in a dialog box and wait for the user to click a button, and returns an integer
indicating which button the user clicked.
Following is an expanded MessageBox

Syntax :
MsgBox ( Prompt [,icons+buttons ] [,title ] )
memory_variable = MsgBox ( prompt [, icons+ buttons] [,title] )
Prompt : String expressions displayed as the message in the dialog box. If prompt consist of more than
one line, you can separate the lines using the vbrCrLf constant.
Icons + Buttons : Numeric expression that is the sum of values specifying the number and type of
buttons and icon to display.
Title : String expression displayed in the title bar of the dialog box. If you omit title, the application name
is placed in the title bar.
Icons
Constant Value Description
vbCritical 16 Display Critical message icon
vbQuestion 32 Display Warning Query icon
vbExclamation 48 Display Warning message icon
vbInformation 64 Display information icon
Buttons
Constant Value Description
vbOkOnly 0 Display OK button only
vbOkCancel 1 Display OK and Cancel buttons
Display Abort, Retry and Ignore
vbAbortRetryIgnore 2
buttons
 Display Yes, No and Cancel
vbYesNoCancel 3
buttons
vbYesNo 4 Display Yes and No buttons
vbRetryCancel 5 Display Retry and Cancel buttons
Return Values
Constant Value Description
vbOk 1 Ok Button
vbCancel 2 Cancel Button
vbAbort 3 Abort Button
vbRetry 4 Retry Button
vbIgnore 5 Ignore Button
vbYes 6 Yes Button
vbNo 7 No Button
Following is an example illustrates the use of message boxes
* Open a new Project and save the Form as messageboxdemo.frm and save the Project as
messageboxdemo.vbp
* Design the application as shown below.
Object Property Setting
Form Caption MessageBoxDemo
Name frmMessageBoxDemo

Label Caption lblName

Name Name

TextBox Name txtName

Text ( empty )

ListBox Name lstName

CommandButton Caption Add

Name cmdAdd

CommandButton Caption Delete

Name cmdDelete

CommandButton Caption Exit

Name cmdExit
Following code is entered in the txtName_Change ( ) event
Private Sub txtName_Change()
If Len(txtName.Text) > 0 Then
cmdAdd.Enabled = True
End If
End Sub
Following code has to be entered in the cmdAdd_Click ( ) event
Private Sub cmdAdd_Click()
answer = MsgBox("Do you want to add this name to the list box?",
vbExclamation + vbYesNo,
"Add Confirm")
If answer = vbYes Then
lstName.AddItem txtName.Text
txtName.Text = ""
txtName.SetFocus
cmdAdd.Enabled = False
End If
End Sub
Following code is entered in the cmdDelete_Click ( ) event
Private Sub cmdDelete_Click()
Dim remove As Integer
remove = lstName.ListIndex
If remove < 0 Then
MsgBox "No names is selected", vbInformation, "Error"
Else
answer = MsgBox("Are you sure you want to delete " & vbCrLf & "the selected
name?",_
vbCritical + vbYesNo, "Warning")
If answer = vbYes Then
If remove >= 0 Then
lstName.RemoveItem remove
txtName.SetFocus
MsgBox "Selected name was deleted", vbInformation, "Delete Confirm"

End If
End If
End If
End Sub
Following code is entered in the cmdExit_Click ( ) event
Private Sub cmdExit_Click()
answer = MsgBox("Do you want to quit?", vbExclamation + vbYesNo, "Confirm")
If answer = vbYes Then
End
Else
MsgBox "Action canceled", vbInformation, "Confirm"
End If
End Sub
Save and run the application. You can notice the different type of message box types are used to perform
an action

Mouse Events In Visual Basic 6

Visual Basic responds to various mouse events, which are recognized by most of the controls. The main
events are MouseDown, MouseUp and MouseMove. MouseDown occurs when the user presses any
mouse button and MouseUp occurs when the user releases any mouse button. These events use the
arguments button, Shift, X, Y and they contain information about the mouse's condition when the button is
clicked.
The first argument is an integer called Button. The value of the argument indicates whether the left, right
or middle mouse button was clicked. The second argument in an integer called shift. The value of this
argumnet indicates whether the mouse button was clicked simultaneously with the Shift key, Ctrl key or
Alt key. The third and fourth arguments X and Y are the coordinates of the mouse location at the time the
mouse button was clicked. As the Form_MouseDown( ) is executed automatically whenever the
mouse button is clicked inside the Form's area the X, Y co-ordinates are referenced to the form.
Positioning a control
MouseDown is the commonly used event and it is combined wiyth the move method to move an Image
control to different locations in a Form. The following application illustrates the movement of objects
responding to move events. it makes use of two OptionButton Controls, two image controls and a
CommandButton. The application is designed in such a way that when an OptionButton is selected, the
corresponding image control is placed anywhere in the form whenever it is clicked.
Open a new standard EXE project and save the Form as Move.frm and save the project as Move.vbp
Design the Form as shown below.

Object Property Setting

Form Caption MouseDown
Name frmMouseDown

OptionButton Caption Credit card is selected

Name optCredit
Value True

OptionButton Caption Cash is selected

Name optCash

Image Name imgCredit

Picture c:/credit.jpg

Image Name imgCash

Picture c:/cash.jpg

The follwoing code is entered in the general declarations section of the Form.
Option Explicit
The following code is entered in the Form_MouseDown( ) event
Private Sub Form_MouseDown(Button As Integer, Shift As Integer, X As Single,
Y As Single)
If optCredit = True Then
imgCredit.Move X, Y
Else
imgCash.Move X, Y
End If
End Sub
Run the application by keying in F5. You can notice that when the mouse is clicked on the form
somewhere, the selected image moves to that clicked location. This is shown in the below figure.

Graphical Mouse Application In Visual Basic 6

The mouse events can be combined with graphics methods and any number of customized drawing or
paint applications can be created. The following application combines MouseMove and MouseDown
events, and illustrates a drawing program.
Open a new Standard EXE project and save the Form as Draw.frm and save the Project as Draw.vbp.
Name the caption of the as Drawing. Add command button control and name the caption of it as Clear
Enter the following code in the Form_MouseDown ( ) procedure, Form_MouseMove ( ) procedure and
cmdClear_Click ( ) procedures respectively.
Private Sub cmdClear_Click()
frmDraw.Cls
End Sub
Private Sub Form_MouseDown(Button As Integer, Shift As Integer, X As Single,
Y As Single)
frmDraw.CurrentX = X
frmDraw.CurrentY = Y
End Sub
Private Sub Form_MouseMove(Button As Integer, Shift As Integer, X As Single,
Y As Single)
If Button = 1 Then
Line (frmDraw.CurrentX, frmDraw.CurrentY)-(X, Y)
End If
End Sub
Button value 1 indicates that the left mouse button is clicked. The code written in the MouseDown event
changes the CurrentX and CurrentY to the coordinates where the mouse button was just clicked.
Run the application. You can notice that when the mouse is clicked and moved in the Form a line is
drawn corresponding to the mouse movement. Following figure illustrates the combined action of
MouseDown and MouseMove.
The program uses two graphics related Visual Basic concepts, the Line method and the CurrentX and
CurrentY properties. Line method is preferred to draw a line in a Form. The following statement draws a
line from the coordinates X = 2500, Y = 2000, X = 5000, Y = 5500
Line (2500, 2000) - (5000, 5500)
The CurrentX and CurrentY properties are not visible in the properties window of the Form because it
cannot be set at the design time. After using the Line method to draw a line in a Form, Visual Basic
automatically assigns the coordinate of the line's end point to the CurrentX and CurrentY properties of the
Form on which the line is drawn.
( Download the source code )
MouseMove application
Visual Basic does not generate a MouseMove event for every pixel the mouse moves over and a limited
number of mouse messages are generated per second by the operating environment. The following
application illustrates how often the Form_MouseMove ( ) event is executed.
Open a new standard EXE project and save the form as MouseMove.frm and save the Project as
MouseMOve.vbp. Place a CommandButton control and name the caption as Clear and set the name as
cmdClear.
The following code is entered in the cmdClear_Click ( ) and Form_MouseMove ( ) events
respectively.
Private Sub cmdClear_Click()
frmMouseMove.Cls
End Sub
Private Sub Form_MouseMove(Button As Integer, Shift As Integer, X As Single,
Y As Single)
Circle (X, Y), 70
End Sub
The above procedure simply draws small circles at the mouse's current location using the Circle method.
The parameter x, y represent the centre of the circle, and the second parameter represents the radius of
the circle.
Save the application and run. You can notice that when the mouse is moved inside the Form, circles are
drwan along the path of the mouse movement as shown in below figure. And also you can notice the
circles are widely spaced when the mouse is moved quickly. Each small circle is an indication that the
MouseMove event occured and the Form_MouseMove ( ) procedure was executed.
Visual Basic 6 -Error handling and Debugging and File
Input/Output
Error Handling enables programmers to write clearer, more robust, more fault-tolerant programs. Error
handling enables the programmer to attempt to recover (i.e., continue executing) from infrequent fatal
errors rather than letting them occur and suffering the consequences (such as loss of application data). If
an error is severe and recovery is not possible, the program can be exited "gracefully"-all files can be
closed and notification can be given that the program is terminating. The recovery code is called an error
handler.
Error handling is designed for dealing with synchronous errors such as an attempt to divide by 0 (that
occurs as the program executes the divide instruction). Other common examples of synchronous errors
are memory exhaustion, an out-of-bound array index, and arithmetic overflow. Error handling provides the
programmer with a disciplined set of capabilities for dealing with these types of errors.
Error-handling code varies in nature and amount among software systems depending on the application
and whether or not the software is a product for release. Products tend to contain much more error-
handling code than is contained in "casual" software.
Usually, error-handling code is interspersed throughout a program's code. Errors are dealt with the places
in the code where errors are likely to occur. The advantage of this approach is that a programmer reading
the code can see the error handling in the immediate vicinity of the code and determine if the proper error
handling has been implemented.
The problem with the scheme is that code in a sense becomes "polluted" with error handling. It becomes
difficult for a programmer concerned with the application itself to read the code and determine if the code
is working is correctly. Error handling often makes the code more difficult to understand and maintain.
When Error Handling should be used
Error handling should be used to process only exceptional situations, despite the fact that there is nothing
to prevent that programmer from using errors as an alternate form of program control.
This lesson explains about error handling and debugging in easy steps with quick examples