Visual Basic 6.0 Tutorial Tips and Tricks

Download Inventory and Delivery Sistem Source Code

2011-01-13T19:08:00.000-08:00

Download Inventory and Delivery Sistem Source Code, this project using Visual Basic 6.0 and MySql database.

Download Source : Delivery.rar
Download Database : Database.rar
Download Ocx : Ocx.rar
Download MySql Connector

username="username"
password="password"

POS Aplication Ver 3.1

2011-01-06T17:59:00.000-08:00

POS Aplication Ver 3.1 was made with Visual Basic 6.0 programming language and MySQL database. This program can be used as a reference for beginner programmers, especially those like Visual Basic 6.0, or can be directly used to store or your minimarket.. read more

InputBox Function in Visual Basic 6 (VB6)

2009-10-28T18:45:00.000-07:00

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.

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 Name	InputBox test frmInputBox
Label	Caption Name	You entered lbl1
Label	Caption Name BorderStyle	( empty) lbl2 1-Fixed Single
CommandButton	Caption Name	OK 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

Download Sourcecode

Visual Basic 6.0 Portable Edition Free Download

2009-10-26T00:26:00.000-07:00

Visual Basic 6.0 Portable Edition Free Download here

Link Download Here

Sample Project Simple Celluler

2009-10-20T18:51:00.000-07:00

The sample project simple celluler is mini aplication for mobile shop, this aplication made in Indonesian version using Visual Basic 6.0 programming language and crystal report 8.5. Database using Microsoft Access 2003. and Data Source Name (DSN) connection database using ODBC. How to create DSN read here

Download Source Code
Download Ocx

Create Data Source Name (DSN) Using ODBC and Microsoft Access

2009-10-20T18:49:00.000-07:00

How to Create Data Source Name Using ODBC and Microsoft Access, follow this intruction below:
1. Open Control Panel - Administrative Tools - Data Sources (ODBC).

2. Choose File DSN Tab - Click Add - Choose Microsoft Access Driver(*.mdb) - Click Next - Then Click browse - Make the name of DSN File - Click Save

3. Click Next - Click Finish

4. Cick select button and choose where you store the microsoft access databse

5. Finish

Piecing Separate Numbers Together to Form a Date or Time Value

2009-10-20T05:07:00.000-07:00

Piecing Separate Numbers Together to Form a Date or Time Value.

In the previous examples, we saw ways to isolate parts of a date/time value. What if you need to go the "other way"? If you have the separate parts of a date/time value in different variables and want to piece them together to formulate a date or time, there are two functions you can use to do this: DateSerial and TimeSerial.

The DateSerial takes three numeric arguments: year, month, and day respectively. It returns a date based on those values.

Example:

Dim intYear As Integer

Dim intMonth As Integer

Dim intDay As Integer

Dim dtmNewDate As Date

intYear = 2001

intMonth = 9

intDay = 2

dtmNewDate = DateSerial(intYear, intMonth, intDay)

' returns 9/2/2001

The TimeSerial takes three numeric arguments: hour, minute, and second respectively. It returns a time based on those values.

Example:

Dim intHour As Integer

Dim intMinute As Integer

Dim intSecond As Integer

Dim dtmNewTime As Date

intHour = 11

intMinute = 34

intSecond = 44

dtmNewTime = TimeSerial(intHour, intMinute, intSecond)

'returns 11:34:44 (AM)

The DatePart Function

2009-10-20T05:05:00.001-07:00

The DatePart Function in VB6,

The generic DatePart function returns an Integer containing the specified part of a given date/time value. Thus, it incorporates the functionality of the Weekday, Month, Day, Year, Hour, Minute, and Second functions. In addition, it can used to get the quarter of a given date (1 through 4) , the "Julian" date (the day of the year from 1 to 366), and the week number (1 through 53).

Syntax:

DatePart(interval, date[,firstdayofweek[, firstweekofyear]])

The DatePart function syntax has these parts:

Part

Description

interval

Required. String expression that is the interval of time you want to return.

The string expression can be any of the following:

Expression	Description	Possible Range of Values
"yyyy"	Year	100 to 9999
"q"	Quarter	1 to 4
"m"	Month	1 to 12
"y"	Day of year	1 to 366 (a "Julian" date)
"d"	Day	1 to 31
"w"	Weekday	1 to 7
"ww"	Week	1 to 53
"h"	Hour	0 to 23
"n"	Minute	0 to 59
"s"	Second	0 to 59

date

Required. Date value that you want to evaluate.

firstdayofweek

Optional. A constant that specifies the first day of the week. If not specified, Sunday is assumed.

firstweekofyear

Optional. A constant that specifies the first week of the year. If not specified, the first week is assumed to be the week in which January 1 occurs.

Date Time Functions In Visual Basic 6.0

2009-10-20T05:03:00.000-07:00

Date Time Functions In Visual Basic 6.0.Recall the VB keywords that reference the current date and/or time:

Now Returns the current date and time together

Date Returns the current date

Time Returns the current time

The following functions isolate the date portion and time portion, respectively, of a Date/Time value:

Function	Description
DateValue	Returns the date portion of a Date/Time value, with the time portion "zeroed out". (Note: When the time portion of a date/time variable is "zeroed out", the time would be interpreted as 12:00 AM.) Example: Dim dtmTest As Date dtmTest = DateValue(Now) At this point, the date portion of dtmTest is 8/31/2001, with a time portion of 0 (12:00 AM midnight).
TimeValue	Returns the time portion of a Date/Time value, with the date portion "zeroed out". (Note: When a date/time variable is "zeroed out", the date will actually be interpreted as December 30, 1899.) Example: Dim dtmTest As Date dtmTest = TimeValue(Now) At this point, the time portion of dtmTest is 9:15:20 PM, with a date portion of 0 (12/30/1899).

The following functions are used to isolate a particular part of a date:

Function

Description

Weekday

Returns a number from 1 to 7 indicating the day of the week for a given date, where 1 is Sunday and 7 is Saturday.

Example:

intDOW = Weekday(Now) ' intDOW = 6

Note:

When necessary to refer to a day of the week in code, VB has a set of built-in constants that can be used instead of the hard-coded values 1 thru 7:

Constant Value

vbSunday 1

vbMonday 2

vbTuesday 3

vbWednesday 4

vbThursday 5

vbFriday 6

vbSaturday 7

Function	Description
WeekdayName	Returns a string containing the weekday name ("Sunday" thru "Saturday"), given a numeric argument with the value 1 through 7. Example: strDOW = WeekdayName(6) ' strDOW = "Friday" The WeekdayName function takes an optional, second argument (Boolean) indicating whether or not to abbreviate the weekday name. By default, the second argument is False, meaning do not abbreviate and return the full name. If True, the first three letters of the weekday name will be returned: Example: strDOW = WeekdayName(6, True) ' strDOW = "Fri" You can nest the Weekday function within the WeekdayName function to get the weekday name for a given date: Example: strDOW = WeekdayName(Weekday(Now)) ' strDOW = "Friday"
Month	Returns a number from 1 to 12 indicating the month portion of a given date. Example: intMonth = Month(Now) ' intMonth = 8
MonthName	Returns a string containing the month name ("January" thru "December"), given a numeric argument with the value 1 through 12. Example: strMoName = MonthName(8) ' strMoName = "August" The MonthName function takes an optional, second argument (Boolean) indicating whether or not to abbreviate the month name. By default, the second argument is False, meaning do not abbreviate and return the full name. If True, the first three letters of the month name will be returned: Example: strMoName = MonthName(8, True) ' strMoName = "Aug" You can nest the Month function within the MonthName function to get the month name for a given date: Example: strMoName = MonthName(Month(Now)) ' strMoName = "August"
Day	Returns a number from 1 to 31 indicating the day portion of a given date. Example: intDay = Day(Now) ' intDay = 31
Year	Returns a number from 100 to 9999 indicating the year portion of a given date. Example: intYear = Year(Now) ' intYear = 2001

The following functions are used to isolate a particular part of a time:

Function	Description
Hour	Returns an integer specifying a whole number between 0 and 23 representing the hour of the day. Example: intHour = Hour(Now) ' intHour = 21 (for 9 PM)
Minute	Returns an integer specifying a whole number between 0 and 59 representing the minute of the hour. Example: intMinute = Minute(Now) ' intMinute = 15
Second	Returns an integer specifying a whole number between 0 and 59 representing the second of the minute. Example: intSecond = Second(Now) ' intSecond = 20

Fix and Handle Error License Information Activex Control (Ocx files)

2009-10-19T02:26:00.000-07:00

Fix and Handle Error License Information Activex Control (Ocx files) using VB6Cli.exe

What is VB6Cli.exe?

VB6Cli.exe is a utility that is designed to fix design-time license problems with ActiveX Controls that ship with Microsoft Visual Basic 6.0. The utility does not fix third-party controls or controls that are not normally installed by Microsoft Visual Basic 6.0, nor does it enable the use of Remote Data Object (RDO) objects in Visual Basic 6.0 Professional Edition. If you try to use RDO in Visual Basic 6.0 Professional Edition, you may also encounter symptoms II and IV below. The only way to enable RDO is to install Visual Basic 6.0 Enterprise Edition.

VB6Cli.exe will help correct problems with the following symptoms:

Symptom I

When trying to site a control within a project, Microsoft Visual Basic raises the following error dialog:

"License Information For This Component Not Found. You Do Not Have An Appropriate License To Use This Functionality In The Design Environment."

Symptom II

When trying to compile a project, Microsoft Visual Basic raises the following error dialog:

Compile Error : Permission Denied

Symptom III

When using the Application Wizard, Microsoft Visual Basic raises an error dialog similar to:

60: Method ~ of Object ~ failed

Symptom IV

When trying to run a project, Microsoft Visual Basic raises the following error dialog:

Runtime Error '429' : ActiveX Component Can't Create Object

Download VB6Cli.EXE

Using DriveListBox, DirListBox and FileListBox Control in Vb6.0

2009-10-14T02:06:00.000-07:00

How to using DriveListBox, DirListBox and FileListBox control in Vb6.0.

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.

Access to MySQL Converter

2009-10-12T03:43:00.000-07:00

Access to MySQL Converter is a small program that will convert Microsoft Access Databases to MySQL.

Wizard interface.
Transfer data directly from one server to another.
Create a dump file.
Select tables to transfer.
Select fields to transfer.
Transfer password protected databases.
Supports both shared security and user-level security.
Optional transfer of indexes.
Optional transfer of records.
Optional transfer of default values in field definitions.
Identifies and transfers auto number field types.
Command line interface.
Easy install, uninstall and upgrade.

Using Access to MySQL

When you start the program it will run you through a wizard. The wizard will ask you all the necessary questions to setup the database transfer. In the first step you are asked to supply the file name of the Microsoft Access Database to convert.

If your Access database requires you to log in you can specify a user name, password and a system database.

Download Access to Mysql

"Unrecognized Database Format" Error Message

2009-10-10T21:34:00.000-07:00

"Unrecognized Database Format" Error Message. If you got "Uncrecognized Database" Format" error message, it's probably because the access database version that you work with isn't compatible with your DAO reference.

To add the compatible reference to DAO:
from VB menu choose Project-> References, mark the Microsoft DAO 3.6 Object Library
check box, and press OK.

If you Don't have Microsoft DAO 3.6 Object Library reference, click on browse,
and select the file C:\Program Files\Common Files\Microsoft Shared\Dao\dao360.dll
(If you have Access 2000 installed in your computer you have this file.)
This will add Microsoft DAO 3.6 Object Library reference to your project.
Now mark it and press OK. or see about ADO

Tips and Tricks Visual Basic 6.0 Clear All TextBoxes In A Form

2009-10-05T22:37:00.000-07:00

Tips and Tricks Visual Basic 6.0 Clear All TextBoxes In A Form.
'Add 1 CommandButton and few TextBoxes To Your Form.
'Insert the following code to your form:

Code

Private Sub Command1_Click()
Dim Contrl As Control
For Each Contrl In Form1.Controls
If (TypeOf Contrl Is TextBox) Then Contrl.Text = ""
Next Contrl
End Sub

Tips and Tricks Visual Basic 6.0 Allow Only UpperCase Letters In TextBox

2009-10-05T00:13:00.000-07:00

Tips and Tricks Visual Basic 6.0 Allow only uppercase in textbox.

'Add 1 TextBox To Your Form.
'Insert the following code to your form:

Private Sub Text1_Change()
old = Text1.SelStart
Text1.Text = UCase(Text1.Text)
Text1.SelStart = old
End Sub

or
 

Private Sub Text1_KeyPress(KeyAscii As Integer)
KeyAscii = Asc(UCase(Chr(KeyAscii)))
End Sub

Crystal Report 8.5 Runtimes

2009-10-03T01:48:00.000-07:00

Crystal Report 8.5 Runtimes is tool for run the crystal report file in a application without install Crystal Report Isntaller.

Download Crystal Report 8.5 Runtimes

Mega Upload : Download Cristal Report 8.+ Runtimes
Ziddu : Download cr85setup here note : password for installer is "pw".

Delete File Using Visual Basic 6.0 Code

2009-10-02T20:15:00.000-07:00

Delete File Using Visual Basic 6.0 Code

Private Sub filedelete(filename As String)

 Dim filesystemobject As Object

 Set filesystemobject = CreateObject("Scripting.filesystemobject")

filesystemobject.deletefile filename, True

End Sub

Private Sub Command1_Click()

filedelete (filename)

End Sub

Note : (filename) is location and file name of the file you will deleted 

Connection Visual Basic 6.0 With MySql Database

2009-10-01T21:05:00.000-07:00

Connection Visual Basic 6.0 With MySql Database.

First step you must download MySql ODBC 5.15, and istall it. after it insert ADO Data Control Component in to your project.

Then create a form , add a adodc component and a command button, see picture below.

Write this code to command button procedure.

Private Sub Command1_Click()
Dim myConnection As New ADODB.Connection
Set myConnection = New ADODB.Connection
myConnection.ConnectionString = "Provider=MSDASQL.1;" & _
"Persist Security Info=False;Data Source=yourdatasourcename"
myConnection.Open

    If myConnection.State = adStateOpen Then
        MsgBox "Connection Success"
    Else
        MsgBox "Connection Failed"
    End If
    myConnection.Close

End Sub

Download source

For any question comment this post..!

Tips and Tricks Visual Basic 6.0 Make A Resizeable Text Box

2009-09-30T19:55:00.001-07:00

Tips and Tricks Visual Basic 6.0 Make A Resizeable Text Box

'Add a module to your project (In the menu choose Project -> Add Module, Then click Open)
'Add 1 Text Box and 2 Command Buttons to your form.
'Insert this code to the module :
Public Const SWP_DRAWFRAME = &H20
Public Const SWP_NOMOVE = &H2
Public Const SWP_NOSIZE = &H1
Public Const SWP_NOZORDER = &H4
Public Const SWP_FLAGS = SWP_NOZORDER Or SWP_NOSIZE Or _
SWP_NOMOVE Or SWP_DRAWFRAME
Public Const GWL_STYLE = (-16)
Public Const WS_THICKFRAME = &H40000
Public Declare Function GetWindowLong Lib "user32" Alias "GetWindowLongA" _
(ByVal hwnd As Long, ByVal nIndex As Long) As Long
Public Declare Function SetWindowLong Lib "user32" Alias "SetWindowLongA" _
(ByVal hwnd As Long, ByVal nIndex As Long, ByVal dwNewLong As Long) As Long
Public Declare Function SetWindowPos Lib "user32" (ByVal hwnd As Long, ByVal _
hWndInsertAfter As Long, ByVal X As Long, ByVal Y As Long, ByVal cx As Long, _
ByVal cy As Long, ByVal wFlags As Long) As Long

'Insert the following code to your form:
Dim initBoxStyle As Long

Private Sub Command2_Click()
SetControlStyle initBoxStyle, Text1
End Sub

Private Sub Form_Load()
Command1.Caption = "Start Resizing"
Command2.Caption = "Complete Resizing"
initBoxStyle = GetWindowLong(Text1.hwnd, GWL_STYLE)
SetControlStyle initBoxStyle, Text1
End Sub

Private Sub Form_Unload(Cancel As Integer)
SetControlStyle initBoxStyle, Text1
End Sub

Private Sub Command1_Click()
Dim style As Long
style = GetWindowLong(Text1.hwnd, GWL_STYLE)
style = style Or WS_THICKFRAME
SetControlStyle style, Text1
End Sub

Private Sub SetControlStyle(style, X As Control)
Dim r
If style Then
Call SetWindowLong(X.hwnd, GWL_STYLE, style)
Call SetWindowPos(X.hwnd, Form1.hwnd, 0, 0, 0, 0, SWP_FLAGS)
End If
End Sub

Sample Projects CallWindowProc_Demo.Zip

2009-09-29T19:08:00.000-07:00

CallWindowProc_Demo. This project shows how you can call VB functions using a memory pointer with the CallWindowProc API function. Not particularly useful in every day coding but there are situations where this technique could be just the ticket!

Download CallWindowProc_Demo.Zip

App Activate Demo.zip (12KB)

2009-09-28T21:04:00.000-07:00

App Activate Demo.zip (12KB) This project shows how to activate a previous instance of an application. It works even if the previous instance is minimized OR if it has a variable title (like Notepad or Word) OR if the exe being started lives in a different directory than the original instance.

Download App Activate Demo.zip (12KB)

Database tools mysql-connector-odbc-5.1.5-win32.

2009-09-28T20:49:00.000-07:00

Database tools mysql-connector-odbc-5.1.5-win32. MySQL provides standards-based drivers for JDBC, ODBC, and .Net enabling developers to build database applications in their language of choice. In addition, a native C library allows developers to embed MySQL directly into their applications.

Download mysql-connector-odbc-5.1.5-win32.msi

Download Source Code Solitaire

2009-09-27T19:13:00.000-07:00

Download Source Code Solitaire.

This example show how to drag a card across the screen and drop it on its destination. The card sticks there if appropriate but automatically walks back to its original location if not (like in solitaire)

Download here

Tips and Tricks Visual Basic 6.0 Move To The Next TextBox When Enter Pressed

2009-09-26T23:23:00.000-07:00

'Add 2 TextBoxes to your form.
'Insert the following code to your form:

Private Sub Text1_KeyDown(KeyCode As Integer, Shift As Integer)
  If KeyCode = 13 Then Text2.SetFocus
End Sub

Tips and Tricks Visual Basic 6.0 Mark All Characters In TextBox

2009-09-25T05:42:00.000-07:00

'Add 1 TextBox to your form (named Text1)
'When the user will press on the TextBox, all the characters in the TextBox will be marked.
'Insert the following code to your form:

Private Sub Text1_GotFocus()
Text1.SelStart = 0
Text1.SelLength = Len(Text1)
End Sub

Tips and Tricks Visual Basic 6.0 Add A New Line To Existing Text Box Text

2009-09-23T19:58:00.000-07:00

Add new text line to multiline text box through code.

Preparations

Add 1 Command Button to your form (named Command1)

Form Code

Private Sub Command1_Click() Dim NewText As String With Text1 'replace 'My New Text' with the Text you want to add NewText = "My New Text" .SelStart = Len(.Text) .SelText = vbNewLine & NewText End With End Sub Private Sub Form_Load() Text1.Text = "My Initial Text" End Sub

Tips and Tricks Visual Basic 6.0 Force The User To Enter Valid Value In Text Box

2009-09-22T20:22:00.000-07:00

Using the Validate event, you can assure that the user will enter valid value in the text box. "Valid Value" can be anything you define: Phone Number, date, number in certain range, certain strings, and so.
Until he done so, all the other controls are disabled, and he cannot exit the text box.
In this example, the user will not be able to exit the first Text Box, until he type "abc".
To check this code, try to press the button or enter to the second text box.

Preparations

Add 1 Command Button and two Text Boxes to your form.

Form Code

Private Sub Text1_Validate(Cancel As Boolean) Cancel = Text1.Text <> "abc" End Sub

Tips and Tricks Visual Basic 6.0 Undo The Last User Action In Text Box

2009-09-17T22:59:00.000-07:00

Add 1 Text Box and 1 Command Button to your form.
Press the button to undo the last user action.

Module Code

Declare Function SendMessageBynum& Lib "user32" Alias "SendMessageA" _ (ByVal hwnd As Long, ByVal wMsg As Long, ByVal wParam As Long, _ ByVal lparam As Long) Public Const EM_UNDO = &HC7&

Form Code

Private Sub TextUndo(T As TextBox) SendMessageBynum T.hwnd, EM_UNDO, 0, 0 End Sub Private Sub Command1_Click() 'replace the "Text1" below with the name of the Text Box you want to 'apply the Undo on it. Call TextUndo(Text1) End Sub

Tips and Tricks Visual Basic 6.0 Set The Text Box Cursor Position

2009-09-17T22:55:00.001-07:00

Private Sub Form_Load() ' the following line will place the cursor after the ' 4th character Text1.SelStart = 4 End Sub

How To Connection ADO Components

2009-09-15T23:40:00.000-07:00

After you install the ADO components, it's time to learn how to connect a database with these components.

For that follow the steps below:

Select and click on the toolbox Adodc object, then draw the object on the form.
Select and right click Adodc object in the form, then the popup menu will appear. select it and click with the left mouse button ADODC Properties. Property pages dialog box will appear.
Click the Build button, the Data Link dialog box will be displayed properties. This dialog box contains a list of the connection provider. Select "Microsoft Jet 4.0 OLE DB Provider".
Then click the Next button or the Connection tab. In select or enter a database name: you just click the button (...), then point dialog box displayed select Access Database. In this box where you navigate a database stored position.
You can test whether the database is connected or not, that is by clicking the Test Connection button.
Then click Ok button, then click OK one more time. The next step is determine the use of Recordsource Database Nwind.mdb examples. Click Recordsource tab, select the Command Type 2-adCmdTable, and the Table or the stored procedure name select Customers, then click Ok.
Up here you have successfully created a database connection with controls Nwind ADO Objects.

Insert ADO Data Control Component Into Your Project

2009-09-11T22:05:00.000-07:00

To use the ADO Data Control first you have to install the ADO components to your project, follow the steps below:

As a first step, select it and click the menu Project | Components, the components dialog box will appear. This way you will often do to add a component that is not in the standard toolbox.

On the Controls tab, move the scrollbar down, locate and mark the check box on the Microsoft ADO Data Control 6.0 (OLEDB). This control is MSADODC.ocx files contained in the location C: \ Windows \ System32.
Then click the Apply button, then an object or control Adodc name will be added in the toolbox boards, such as the following picture:

Know the ActiveX Data Objects (ADO)

2009-09-09T22:24:00.000-07:00

Microsoft ActiveX Data Objects (ADO) enables us to build a client /server application , that can access and manipulate data from a server to determine in advance its OLE DB. With ADO, which made the application program to communicate with Object Linking and Embeded Database (OLE DB) which memingkinkan we read and process the data directly without the need to convert it first.

In this article, you are expected to understand how to use ADO for database interfaces, whether sourced from the Jet Microsoft Access engine and the SQL Server.

Non-ADO Problems Data Access Visual Basic 6.0

2009-09-08T22:48:00.000-07:00

Control Data in Visual Basic 6.0, is basically designed for the Jet 3.51 database engine, the Microsoft Access 97. But now Microsoft Access database has been enhanced by the passing of Microsoft Access 2000 and XP with Jet 4.0 engine. Control data were not able to handle the connection relationship with the Jet 4.0 database engine or any other type.

Error message will appear if you are using Data Control by setting the record source property window with the Jet 4.0 engine is as follows:

The above error message appears because of differences in the database engine used. Microsoft Access 97 is made by using the Jet 3.51/3.6 database engine. While Microsoft Access 2000 uses Jet 4.0 database engine. Capabilities of the DAO, which is the standard data controls in Visual Basic, just to access the database engine with engine Jet 3.51/3.6 not for Jet 4.0 engine.

Relationship Of Visual Basic With Source Database (2)

2009-09-07T17:00:00.000-07:00

Microsoft ActiveX Data Objects (ADO) enables us to build a client application / server that can access and manipulate data from a server by first determining the OLE DB Provider him. In addition, ADO support in making the Web-based applications. Its main advantage is easy to use, high speed and small memory usage. ADO another specialty of the Remote Data Service (RDS), where you can move data from a server to a client application or Web page, manipulate the data from the client and return it to the server.

With ADO, which made the application program to communicate with Object Linking and Embeded Database (OLE DB) that allows us to read and process the data directly without the need to convert it first. ADO is a Component Object Model (COM) is an automated interface components that can be used in several programming languages including Microsoft Visual Basic 6.0, VBScript, JScript, Visual C + +, and Visual J + +. Most of the existing version of ADO separate from the Microsoft Data Access Components.

Relationship Of Visual Basic With Source Database

2009-09-06T22:24:00.000-07:00

Microsoft Visual Basic 6.0 is one of the visual-based programming language is popular and sophisticated in the Windows environment. As a Software DBMS, we can design, create or build a database application programs and other programs. Microsoft Visual Basic 6.0 is the development of Microsoft's previous versions of Visual Basic. Data access technology that is owned by the Visual Basic 6.0 ActiveX Data Object technology, better known by the name of the ADO. ADO is Microsoft's latest technology to manipulate information from relational databases and non-relational. ADO able to integrate database applications you build with a variety of data sources such as Microsoft Access, SQL Server, ODBC, Oracle and other.

Know Database In Visual Basic 6.0

2009-09-04T22:20:00.001-07:00

If we build a house, you need to design a direct result of the end of the house and determine the steps - steps of development. Without the design, development outcomes will not match the desired results.

Similarly, by creating a database application, you need a good design if you want a good end product. This is very important especially in making a database application.

Database itself is basically a collection of information, usually in a particular order. A common example is a database phone book. This book contains a collection of names, addresses, and phone number. However, the database you will use in this article is the database of the database presented in the form of tables consisting of fields and records. Filed is the smallest part of a record, usually presented in the form of columns. For example the database name in the address book above. While the record is a collection of fields that are presented in the form of lines, such as name, address and phone number.

From the picture above, the information in the record to 4, namely: 4 Dinda Bandung 0226523212
While the information in the field names, namely:
Fariz, Lomri, Dede, Dinda, Susi
A table can be linked with other tables filed corresponding key, which is used to connect the information in one table with some other tables. This relationship in a database known as the Relationship Table (Relationship Table).

Create Multiple Document Interface (MDI) Form In visual Basic 6.0

2009-09-03T19:35:00.000-07:00

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:

Start a new project and then choose Project >>> Add MDI Form to add the parent Form.
Set the Form's caption to MDI Window
Choose Project >>> Add Form to add a SDI Form.
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. ( Download the source code )

Menus In Visual Basic 6.0

2009-09-02T22:51:00.000-07:00

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 menu. (Download the source code)

Know Form In Visual Basic 6.0

2009-09-02T00:46:00.000-07:00

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
Form	Caption Name	Form1 frm1
Form	Caption Name	Form2 frm2
Form	Caption Name	Form3 frm3
Label	Caption Name	Click on a button to display a Form 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.

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. (Download the source code)

Combobox and Listbox Control In Visual Basic 6.0

2009-09-01T00:29:00.000-07:00

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
Enabled	By setting this property to True or False user can decide whether user can interact with this control or not
Index	Specifies the Control array index
List	String array. Contains the strings displayed in the drop-down list. Starting array index is 0.
ListCount	Integer. Contains the number of drop-down list items
ListIndex	Integer. Contains the index of the selected ComboBox item. If an item is not selected, ListIndex is -1
Locked	Boolean. Specifies whether user can type or not in the ComboBox
MousePointer	Integer. Specifies the shape of the mouse pointer when over the area of the ComboBox
NewIndex	Integer. Index of the last item added to the ComboBox. If the 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.

Dropdown combo

Simple 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
Form	Caption Name	ListBox frmListBox
TextBox	Text Name	(empty) txtName
Label	Caption Name	Enter a name lblName
ListBox	Name	lstName
Label	Caption Name	Amount Entered lblAmount
Label	Caption Name Border Style	(empty) lblDisplay 1 Fixed Single
CommandButton	Caption Name	Add cmdAdd
CommandButton	Caption Name	Remove cmdRemove
CommandButton	Caption Name	Clear cmdClear
CommandButton	Caption Name	Exit 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.

Timer Control In Visual Basic 6.0

2009-08-31T00:22:00.000-07:00

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

Picture Box Control In Visual Basic 6.0

2009-08-29T17:26:00.001-07:00

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.

Label and Frame Controls in Visual Basic 6

2009-08-28T19:43:00.000-07:00

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

2009-08-27T20:17:00.000-07:00

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 Name	Enter a Number Label1
TextBox	Text Name	(empty) Text1
CommandButton	Caption Name	&Close Command1
OptionButton	Caption Name	&Octal optOct
OptionButton	Caption Name	&Hexadecimal optHex
OptionButton	Caption Name	&Decimal 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.

TextBox Control In Visual Basic 6.0

2009-08-26T23:33:00.000-07:00

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
Locked	If this control is set to True user can use it else if this control is set to false the control cannot be used
MaxLength	Specifies the maximum number of characters to be input. Default value is 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
Multiline	By setting this property to True user can have more than one line in the 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
Visible	By setting this user can make the Textbox control visible or invisible at 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

Know About Arrays In Visual Basic 6.0

2009-08-25T20:11:00.000-07:00

An arrays 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."

Do And For Statement

2009-08-25T03:45:00.003-07:00

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

Do And For Statement

2009-08-25T03:44:00.003-07:00

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

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

Loops Statements In VIsual Basic 6.0

2009-08-23T23:16:00.000-07:00

A repetition structure allows the programer 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".

Control Structures in Visual Basic 6.0

2009-08-23T23:08:00.000-07:00

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 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 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

Procedures in Visual Basic 6

2009-08-23T22:58:00.000-07:00

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 Program 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.

Variables in Visual Basic 6

2009-08-23T22:47:00.000-07:00

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

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.

Operators in Visual Basic

2009-08-23T22:34:00.000-07:00

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

Structure Applications With Visual Basic Language

2009-08-23T22:18:00.000-07:00

Basic is one of the programming language that is well known by computer users. This language can be considered as the basic programming language or the easiest to match with his name.

However, Basic is really name stands for B (Beginner's), A (All - Purpose), S(Hollywood), I (Instruction), C (Code).

Applications in Visual Basic 6.0 consists of the parts:

· Form

Is the place to design the program by putting the objects that is a series of commands that will be done by the application.

· Control

Having a graphical form that will be placed on field work in the call form that can interact with the user, such as textbox, labelbox, CommandButton. Form and control is the object of this programming.

· Properties

Is a variable or a predicate that is attached to each object. Examples of properties is the name, caption, size, color, content and position. Visual Basic provides the raw value and this value can be changed at the time the program starts.

· Methods

Is a procedure that was made on each object at any time can be used in accordance with the purpose of such method.

· Event Procedure

Is the code associated with each object, which will carry out duties in accordance with the event name in question. This code will react when there is action from the user on the object in question.

· General Procedure

Is yanng codes are not directly related to existing objects. This procedure will run when called by name in a statement the program line.

· Modules

Is a collection of some of the General Procedure, variable declarations and constant definitions used in an application.

Understanding and Optimizing Data Types In Visual Basic 6.0

2009-08-23T21:22:00.001-07:00

In Visual Basic 6 there are 11 different data types. These are Boolean, Byte, Currency, Date, Double, Integer, Long, Object, Single, String, and Variant. They each have a specific purpose and using them correctly will increase your programs performance. I am going to cover the data types most frequently used.

• Boolean

The Boolean data type has only two states, True and False. These types of variables are stored as 16-bit (2 Byte) numbers, and are usually used for flags. For example, lets say that you have a textbox (Text1) and a command button (Command1). You only want Command1 to be Enabled when there is text in Text1. You would do something like this...

Private Sub Form_Load() Command1.Enabled = False ' Disables Command1 Text1.Text = vbNullString ' Sets Text1="" End Sub Private Sub Text1_Change() Dim bEnable As Boolean If Text1.Text <> "" Then bEnable = True Command1.Enabled = bEnable End Sub

Run the program and Command1 will only be enabled when there is text typed into Text1.
• Byte

The Byte data type is an 8-bit variable which can store value from 0 to 255. This data type is very useful for storing binary data. It can also be very useful when sending/receiving byte values to/from a Basic Stamp or PIC.
• Double

The Double data type is a 64-bit floating point number used when high accuracy is needed. These variables can range from -1.79769313486232e308 to -4.94065645841247e-324 for negative values and from 4.94065645841247e-324 to 1.79769313486232e308 for positive values.
• Integer

The Integer data type is a 16-bit number which can range from -32768 to 32767. Integers should be used when you are working with values that can not contain fractional numbers.
• Long

The Long data type is a 32-bit number which can range from -2,147,483,648 to 2,147,483,647. Long variables can only contain non-fractional integer values. I myself use Long variables over Integers for increased performance. Most Win32 functions use this data type for this reason.
• Single

The Single data type is a 32-bit number ranging from -3.402823e38 to -1.401298e-45 for negative values and from 1.401298e-45 to 3.402823e38 for positive values. When you need fractional numbers within this range, this is the data type to use.
• String

The String data type is usually used as a variable-length type of variable. A variable-length string can contain up to approximately 2 billion characters. Each character has a value ranging from 0 to 255 based on the ASCII character set. Strings are used when Text is involved.
Putting All Of This Technical Stuff To Use

Just to show you how to use these data types, here is a small example. Lets say that we have a String containing the text, "This VB stuff is pretty darn cool..!", and we want to convert each letter to it's ASCII equivalent. We will then display each letter along with its ASCII equivalent in a MessageBox one at a time.

Private Sub Command1_Click() Dim sText As String Dim lTextLength As Long Dim sChar As String Dim bASCII As Byte Dim x As Long sText = "This VB stuff is pretty darn cool..!" lTextLength = Len(sText) 'Gets # of chars in sText For x = 1 To lTextLength 'Loop through string one char at a time sChar = Mid$(sText, x, 1)'Gets the x'th charcter in sText bASCII = Asc(sChar) 'Gets ASCII value of character MsgBox "The ASCII value of '" & sChar & "' is " & bASCII 'Display results Next x End Sub

Now run the code and it will display one character at a time along with it's ASCII value.

Difference Of Basic with Visual Basic

2009-08-22T01:48:00.000-07:00

Because the Visual Basic language that offers the concept of object-oriented, then the Visual Basic offers the advantages that more of the old programming language, that is BASIC . Does not leave with all the statements used in the previous generation, Visual Basic can be cut off so many statements and instruction program to the statement in a more simple to implement instruction so long.

You can mark an action to the object that is created in the Visual Basic and save the object as a collection of statements that can be directly executed.

Other merit, Visual Basic offers so much "equipment" in designing a program. You can imagine how difficult a simple BASIC language displays an image that is so complex. However, with Visual Basic this process the more easily executed.

Free Download Tutorial and Sample Program

2009-08-20T21:55:00.000-07:00

TUTORIAL

1. Visual basic tutorial download here
2. Visual basic tutorial (ADODC) download here
3. Visual basic sample program download here

Object Oriented Programing

2009-08-20T21:37:00.000-07:00

Programming with object-oriented concept offers a simple. You can imagine what a time you want to make a car without digging up of various spare parts for each part of the car.
Make a program with Visual Basic language can be as you make a car. In programming, object oriented, Visual Basic does not make you dizzy to make a "tire", "rearview mirror", and other from applications that want to make.
Visual Basic does not make you dizzy just to create the application to be made. With the object that is integrated in the language, you can generate all the object program was designed to. You only pay for the charge structure of the program, but to let the visual Visual Basic handles.

Visual Basic Programming

2009-08-20T20:29:00.000-07:00

Visual Basic is a programming language that uses the concept of programming, "visual". The concept of "visual" offers so much convenience in designing a program.
Microsoft Visual Basic was first introduced by the software company Microsoft Corporation. Start version 1.0, up to now in the release of Visual Basic. Net.
What Micrososft offered as the author is quite simple, engage "face" to the BASIC language in a more modern concept, namely concept "object oriented programming" or programming that oriented on the object and based on the Windows operating system.