|
|
RNSIT Visual Basic |
Profsr.com <http://profsr.com/>
[image: Previous page] Previous
<http://www.profsr.com/vb/vbless04.htm> [image:
TOC] Contents <http://www.profsr.com/vb/vbintro.htm#content> [image:
Next page]Next <http://www.profsr.com/vb/vbless06.htm>
------------------------------
LESSON 5 -- More standard controls
Working with arrays Before we get to today's lesson we will cover a bit of
programming theory on Arrays.
In VB, arrays work in much the same way as they do in all other languages
you have studied. By definition an array is *an indexed variable*, meaning
it is one variable with many parts, each part being referenced by an index
number. The index number being numeric, it can be manipulated by loop
statements, incremented, decremented, etc. An array can contain any valid
data type and, if it is of the Variant type, can even contain elements of
different types.
An array is declared like any other variable, with the addition of an index:
* Dim Department(6) As String
*
will declare an array of 7 elements of the String type (we assume that it
will be 7 Department names). The only problem with this declaration is that
the index goes from 0 to 6. So, if you want the name of the sixth Department
you have to specify Department(5), which can be confusing at times.
To work around this problem you can specify the starting index in the
declaration:
*Dim Months(1 To 12) As String*
Thus, Months(1) is January and Months(12) is December.
You don't even have to start at 1. If your Sections are numbered 101 - 120
you can define an array:
*Dim Sections(101 To 120) As Integer*
One common method of manipulating arrays is to use For...Next loops:
An array can also be assigned to a variable in code. Look at the following
example and understand that that is *not an implicit declaration*. The
variable "Week" is declared as Variant. It is assigned an *array value* in
code.
Now, when we get to the next set of controls, different kinds of Lists,
these notions may prove useful.
Top <http://www.profsr.com/vb/vbless05.htm#Start>
ListBoxWith the ListBox control the user can select items from a list of
choices. Although the list of choices can be entered in the List property of
the control, as in the example below, this is not a very good habit to get
into. It is essentially "hardcoding" data into the program and it can cause
maintenance headaches.
The common technique for loading a ListBox is to do it in code, with the
Form_Load event. This way, if items have to be added it is a simple matter
to add a line of code.
It is sometimes difficult to distinguish an object's Properties and its
Methods. In the example above we used lst_team.AddItem. What is AddItem? It
is a Method. How do I know? Well, to tell them apart, think of grammar. A
property is a characteristic, something that the object is, a color, a size
- it is like an adjective. A Method is an action, something that it does, in
fact, a verb. When you see object.something_descriptive, it is a Property.
When you see object.some_action, it is a Method.
In the example shown, *AddItem is a Method *because it is the action of
adding items to the ListBox.
If you wanted to remove an item from the list in code, there is a *RemoveItem
Method* for the ListBox. lst_team.RemoveItem 2 would remove the 3rd team -
remember that it starts at 0.
When the Form opens, it will load the list in Form_load before the ListBox
is displayed. If there are too many items for the space allocated to the
ListBox, it will create a vertical scroll bar.
When the user selects one of the teams from the list, we have to have a way
of capturing that information in a variable. That is done with the Text
property of the ListBox: *TeamName = lst_team.Text*
ComboBoxThe ComboBox is called that because it's a combination of a ListBox
and a TextBox. It has the advantage over the ListBox of not taking up space
until it is actually used which means that it makes it easier to position on
the Form.
But the combo has the disadvantage, sort of, that the user can enter his own
information, in addition to what is in the list. This may make data
validation harder because the choices are not limited. When you want to
force the user to make a choice only among the specified items, use a
ListBox, even if it is a bit more awkward. If the user is allowed to
override the choices, uses a ComboBox.
As in the ListBox, use the *Text* property to get the information input. *
Label3.Caption = cbo_position.Text*
As you can see, it is fairly simple to load the ListBox and the ComboBox
during the From_Load event. The only other detail to note is that the order
in which the items appear in the Combo is not the same as the order in which
the items were added. That is intentional - it is done with the
*Sorted*property for the ComboBox. It can also be done for the
ListBox.
Top <http://www.profsr.com/vb/vbless05.htm#Start>
DriveListBox, DirListBox, FileListBoxFor this next example we need to create
a new form, Form2, in the current Project.
*Specifications:* While in Form1, the Registration form, we need to be able
to hit a button which will call-up a new form, the DirList form, which will
look like the example below. This form will allow us to select a type of
file that we want to see and then to select a file, in a directory, in a
drive that will be specified. If the file selected is an executable, we will
run the file. If it is a text file we will call-up Notepad to edit it, and
if it is a graphics file we will call-up the image editor.
In fact, this allows us to call an external program from inside a form. If,
for example, we wish to edit the player's picture before storing it, we can
open the picture file with the image editor, change it, and continue with
the rest of the form.
There are 3 new controls on this form, plus the buttons and the ListBox.
Since you almost always have only one of each of those controls on the form,
we won't bother to change the names of the controls in this example - we
keep them as: Drive1, Dir1, and File1.
The control that shows the current drive is called a *DriveListBox*. The
name of the active drive is in the control's *Drive* property. The selected
drive can be changed, in code, by writing: *Drive1.Drive = "D:"*, for
example.
Don't bother looking for the .Drive property in the Properties window for
Drive1 - you won't find it. Same with Dir1.Path and List1.FileName. That's
because Drive is a runtime property. That is, one that is only available
when the program runs. Makes sense when you think about it. You can design
the DriveListBox to have the size, the color and the font you want but you
can't tell it which drive will be active at runtime. That will have to come
from the system.
VB is full of these details. Every control has properties that are only
accessible at runtime, through code. The only way to find them is to look in
the documentation. A big Reference Manual is handy and the Help function
helps a lot with this, too.
The current directory is in the *DirectoryListBox*. The name is in the *
Dir1.Path* property.
The default event associated with Drive1 and Dir1 is called a
*Change*event. That's because nothing has to be done with those
controls until they
are actually changed. Remember, when the program runs they are automatically
loaded with the current drive and the current directory active.
The current file selected is in the *FileListBox*, in the
File1.FileNameproperty. This one is not automatically loaded because
there is no current
active file. You select a file by clicking on it, generating a *Click*event.
Study the code and then look at the explanations below. To keep the code
section from getting too long, explanations have not been included as
comments.
Program notes:
- First task in Form_Load is to load the list of file types. We only
want to display files that are Executable, Text or Graphics. The .EXE is
selected by default - ListIndex =0.
- The FileListBox *Pattern* property creates the filter for the
selection.
- Whenever we change the Drive selection or the Directory selection, a
*Change event* is generated. When the Drive changes, the Directory's
path changes and when the Directory changes, the list of files changes.
- When you click on the Start button you first have to check if a file
is selected. If not, issue a message.
- The Right() function, which we will look at in Lesson7, checks to
see if the rightmost character of the filename is a \. If it is it means
that the file is in the root directory. If it isn't, we have to add a \
between the path and the filename.
- Based on the type of file selected, we execute the *Shell
function*which runs an executable program. vbNormalFocus is the
*window style argument* that tells the program to run in a normal
window.
- When we click on a file type, the Pattern property for the FieList
must change.
- A double-click on a filename does the same as hitting the Start
button.
- Remember, we called this Form from the Registration form. When we're
done with this, we want to close it and go back to the calling form. The
Exit button does an *Unload* of the current form but, *it does not
execute an End statement* because that would cause the Project to end.
This final section of code is in the Registration form. It is the code for
the Viewer button which calls the DirList form.
The only thing to do is to Load the form using its FormName (from the Name
property) and then to execute its *Show method*. The argument
*vbModeless*means that the form does not get exclusive focus. The
opposite of vbModeless
is *vbModal*. A *modal* form is one which requires action from the user
before it can be closed. Usually, error messages are modal - you have to
respond, usually by hitting the OK or Cancel button, and you can't click on
another form to send this one to the background, and you can't close it with
the close box. A *modeless* form can be sent to the background and it can be
closed at any time.
------------------------------
Top <http://www.profsr.com/vb/vbless05.htm#Start>
Home <http://www.profsr.com/>
Tutorials<http://www.profsr.com/home3.html>
Profsr.com <http://profsr.com/>
[image: Previous page] Previous
<http://www.profsr.com/vb/vbless05.htm> [image:
TOC] Contents <http://www.profsr.com/vb/vbintro.htm#content> [image:
Next page]Next <http://www.profsr.com/vb/vbless07.htm>
------------------------------
LESSON 6 -- Menu and Debug
Creating a Menu No! Not a restaurant menu.
If you've worked with Windows applications before you have worked with
menus. Every Windows application has one. The menu gives the users access to
functions that are not defined as controls (editing, formatting, etc) and
also repeats certain functions that are coded as controls (Exit button, for
example). Menus offer a variety of functionalities to define the
application: we can include sub-menus, checked items, enabled/disabled
functions, toolbar icons. The VB IDE that you are using certainly displays
all of those tools, as in the diagram below.
For this lesson, we will use the Registration form we created in Lesson 5
and we will add a menu to it.
The easiest way to create a menu is to do it with the Application wizard
when creating the application. But since we're not here to do things the
easy way, we'll have to rough-it. In this case, roughing-it is not much
harder. We use the *Menu Editor* that can be found in the Menu bar -->
Tools. Using the Editor is fairly obvious. We just build up the menu bar on
the first level and then, we add sub-menus using the arrow keys to add an
elipsis before the captions. Thus, &File is on the menu bar and ...&Open is
under &File. Items can be inserted anywhere using the Insert button.
You may have noticed the use of the ampersand (&) in the captions (the *
Caption* is the part that will display in the menu bar, not the name). That
is standard Windows practice. It creates a Hot-key, meaning a function that
can be called from the keyboard using the <Alt> key. Putting an & before a
letter in a caption makes that letter the hot-key for the function; <Alt><F>
will call-up File, <Alt><E> will call-up Edit, and so on. Just make sure
that the same hot-key is not used for 2 functions on the same level. In the
menu bar for VB above, note that <Alt><F> is used for File but, <Alt><o> is
used for Format. The hot-key for each function is the letter underlined so
there should'nt be any confusion.
The other consideration when creating the menu is to give each menu item a
specific *name*. In this case we use the prefix mnu_ to identify menu items.
These are important because they will be refered to in code and it should be
clear that mnu_exit is the Exit function in the menu whereas cb_exit is the
Exit command button.
You can run the application at any time while you create the menu, just to
verify that it displays correctly. Of course, if you click on a menu item,
nothing happens. Just like controls, menu items have to be coded to work.
So, we go to the code window and write the code for each of the menu items
that we want to activate. Fortunately, some of it is automatic. Clicking on
a menu item will automatically open lower-level items, if there are any. We
just code for the lowest-level item. For example, for File-->Open-->Viewer,
there is no code for File, nor for Open but, we must write the code to
execute for when Viewer is clicked.
For this example we will code a few simple operations to show how it is
done. From this it is just a question of expanding the menu to display more
functions.
When working with forms, there is always a certain amount of data validation
that has to be done. Data validation consists of making sure the data is
correct before doing calculations and so on. Usually, until the data is all
correct certain functions such as calling the database or going to the next
form have to be made unavailable - we say that the function is *disabled*.
To complete the example, let's say that we want to disable the Viewer option
if the player's name has not been entered. To do this we add some code in
the Go button. The code consists of setting the *Enabled property to
False*if we want to disable a control or menu item; we set the
property to True to
enable the control again. When disabled, the Caption goes gray and the code
cannot be executed. In the case of Viewer, where we have both a button and a
menu function, we must remember to disable both.
Top <http://www.profsr.com/vb/vbless06.htm#Start>
Debugging codeAfter six lessons of this tutorial, it would be surprising if
you had never had a bug in the code you've been writing. By now you should
have written some original code for yourself, not just the examples supplied
with the lessons. Whenever you write code there is the possibility of making
mistakes. Heck! even Professors make them, although very rarely. It can be
very frustrating to try to find an error when you don't know where to begin
to look. But there are techniques that can help.
Do you know where the term "*bug*", for a program error, comes from? In
case you've never heard the story before, here it is, as told by Grace
Hopper, one of the pionneers of programming.
In the late 40's even a simple computer was a big thing: 1000's of vacuum
tubes and 1000's of square feet of floor space. A group of programmers were
working late one hot summer night. To help to dissipate all the heat
generated by those tubes, all the windows were open. At one point the
program that they were working on bombed-out. Eventually they found the
problem: a moth had flown in and had become lodged in the wiring, creating a
short-circuit. Afterwards, every time a program would crash the programmer
would exclaim, "There must be a bug in the machine!". To this day that has
remained one of the mainstays of programmers: when the program goes wrong,
blame the hardware!
One of the first techniques to master is the use of *breakpoints.* A
breakpoint is a flag at a given point in code where program execution will
be suspended to give you time to look at the content of variables or at the
status of properties. When VB hits a breakpoint when running a program, the
code window opens and an *immediate window* opens at the bottom of the
screen. You can look at variables or properties in the immediate window and
then, either do *Start* to resume execution or do *Step*, using *<F8>* to
step through the execution, one statement at a time.
Again we will use the code from Lesson 5. In the code window, click the
column to the left of a line of code. This will create a breakpoint
indicated by a red dot (you remove the breakpoint by clicking on the red
dot). When you run the program it will stop at the breakpoint. In the
immediate window, look at the content of different variables or properties.
Step through the code with <F8>; the active statement is indicated by the
yellow arrow. All the logic represented by IF or LOOP or DO statements will
be executed according to the conditions present. If the yellow arrow jumps
to a line that you don't expect, find the reason why.
Another technique to learn is called *"error trapping"*. It consists in
intercepting errors that can occur at execution rather than programming
mistakes, although not providing for user errors can be considered a
programming mistake.
Let's build a simple example. The user will input 2 numbers, a numerator and
a denominator. The program will divide the numerator by the denominator and
display the result. Easy so far. However, if the user inputs 0 for the
denominator, the program crashes because programming cannot make sense of
division by zero. So, we want to *trap the error* and process it before it
displays an error message to the user. We will use the *On Error GoTo
... *statement.
This tells the program that if there is some kind of run-time error, go to
the error-processing-routine named. We have to create a *line label* to
identify the error routine; a line label has a colon at the end, like
error_rtn:, in the example. At the same time, there is an *Err
object*created and it contains, among other things, a
*Number property* that will identify the error. For example, if Err.Number =
11, the error was a division by zero; Err.Number = 6 represents an overflow
situation.
It is worth noting that line labels in code do not end processing in any
way. When the logic gets to a line label it keeps on going. The programmer
has to make sure that the processing of errors in the error_rtn is not done
automatically every cycle (that is called "falling through" the next routine
and it's a common error).
------------------------------
Top <http://www.profsr.com/vb/vbless06.htm#Start>
Home <http://www.profsr.com/>
Tutorials<http://www.profsr.com/home3.html>
Profsr.com <http://profsr.com/>
[image: Previous page] Previous
<http://www.profsr.com/vb/vbless06.htm> [image:
TOC] Contents <http://www.profsr.com/vb/vbintro.htm#content> [image:
Next page]Next <http://www.profsr.com/vb/vbless08.htm>
------------------------------
LESSON 7 -- Text, Graphics and Multimedia
Manipulating text Whenever you are entering data, creating files or
databases, you are working with text strings. Text strings contain
characters that can be copied, deleted, cut and reassembled but they also
have important visual characteristics: size, color, weight, transparency,
etc. In this lesson we will look at different ways of manipulating those
text strings.
String functionsHere is a list of the basic functions that work with
strings:
- *Len(string)*: returns the length of *string*, the number of
characters it contains.
- *Left(string, number)*: returns the number of characters specified
by *number* from the left end of *string*.
- *Right(string, number)*: returns the number of characters specified
by *number* from the right end of *string*.
- *Mid(string, position, number)*: returns the number of characters
specified by *number* starting at character number *position* from the
left end of *string*.
- *InStr(string1, string2)*: returns the position of *string2* in *
string1* - returns 0 if *string2* is not found in *string1*.
- *LTrim(string), RTrim(string) and Trim(string)*: returns
*string*with non-significant spaces removed from the left, the right
or both,
respectively.
- *LCase(string), UCase(string)*: returns *string *converted to
lower-case or upper-case, respectively.
Formatting Numbers, Dates and TimesThe Label control is still the easiest
way of displaying the result of calculations. Whatever the answer is, just
move it to Label5.Caption and it will appear on the form. Unfortunately, it
does not always appear the way you want to see it. No problem if the result
is a string but, what if it is a dollar amount or a date of some kind. That
will require some formatting of the result before displaying it. We use the
*Format function*: *Label5.Caption = Format(result, "formatting characters")
*
NumbersFor example, given that:
*Dim result As Single
result = 3456.7
Label5.Caption = Format(result, "00000.00") 'displays:
03456.70
Label5.Caption = Format(result, "#####.##") 'displays:
3456.7
Label5.Caption = Format(result, "##,##0.00") 'displays: 3,
456.70
Label5.Caption = Format(result, "$##,##0.00") 'displays: $3,
456.70 *
Here is a list of what the formatting characters mean:
0 represents a digit, with non-significant leading and trailing zeros
# represents a digit, without non-significant leading and trailing zeros
. decimal placeholder , thousands separator $ + - ( ) space literal
character; displayed as typed
When displaying dollar amounts, it is good practice to always use the 0
placeholder with the decimal so that *10 cents *does not come out as *$.1*or
*$0.1* Using the formatting string *"$#0.00"* ensures that the value follows
standard rules and comes out as *$0.10*.
Dates and TimesWhen working with dates and times, you need to know that
there is a function that will obtain the current date and time from the
system clock. The function is: *Now( )* and you can use it directly as in: *
Label5.Caption = Now( )*
The result is the current date and time formatted according to what you
specified in the Windows Control Panel for your system. If you want to
format the result, because you don't want to see the time, for example,
there are formatting characters for date and time, as there are for numbers.
The main characters are:
yy year without the century - eg: 00 yyyy year with century - eg:
2000 m month number - eg: 12 mmm short name of month - eg: dec mmmm long
name of month - eg: december d day of the month, without zero - eg:
8 dd day
of the month, with zero - eg: 08 dddd name of the day of the week - eg:
Monday h hour, without zero - eg: 7 hh hour, with zero - eg: 07
mm minutes
- eg: 45 ss seconds - eg: 55
Thus, if Now( ) is July 8, 2000 , *Label5.Caption = Format(Now( ), "dddd,
yyyy mmmm dd")
returns: Saturday, 2000 July 08*
Of course any other date can be formatted for display: *Label5.Caption =
Format( DateOfBirth, "yyyy-mm-dd")*
Named FormatsIn addition to the formatting string, there are several *named
formats* that can be used to determine the output format. These named
formats are VB constants that you call when you need them:
General Number Number with no thousands separator Currency Thousands
separator, two digits to the right of decimal Fixed Displays at least one
digit to the left and two digits to the right of decimal Standard Thousands
separator, at least one digit to the left and two digits to the right of
decimal Percent Multiplies by 100, add percent sign to the right General
Date Display determined by Control panel settings; displays date and
time Long
Date Long date format specified for system Short Date Short date format
specified for system Long Time Long time setting specified by system;
includes hours, minutes, seconds Short Time Shows hours and minutes
*Dim DateHired As Date
DateHired = "1995-10-25"
Label5.Caption = Format(DateHired, "Long Date")
returns: October 25, 1995*
Manipulating blocks of textThe *TextBox* and the *ComboBox* controls contain
several properties which will allow you to manipulate blocks of text, in
addition to single characters.
If you have to input a large quantity of text in a TextBox, for example, you
do not want to see it all in a single line. There are 2 properties that you
set that will make the data easier to see:
- *MultiLine = True* allows you to have several lines of input, all
separated by <Enter>.
- *ScrollBars = 2 - Vertical* will create scrollbars, useful to read
text.
Then there are 3 properties to work with a *block of selected text* in the
control:
- *SelStart* an integer number identifying the start of selected text,
the position of the first character in the block - starts at 0.
- *SelLength* an integer number identifying the number of characters
selected in the block.
- *SelText* a string containing the selected text.
Note that this kind of manipulation is usually done with the mouse. However,
you do not have to code for the mouse events. It is automatic - when you
select text in a control, the appropriate events, MouseDown, MouseUp and
MouseMove, are triggered by the control.
Useful objects: Screen and ClipboardThe *Screen object* represents the
complete Windows environment. It allows access to all Forms and Controls. It
has *2 important properties* that we need:
- *ActiveForm* returns the name of the Form currently active.
- *ActiveControl* returns the name of the Control that currently has *
focus*.
In the example that follows we will use these properties to avoid having to
name the form and the control in code. This is a way of implementing
*re-usability
of code*, an important design principle - we can write code that can be
re-used in many applications without having to be re-written.
The *Clipboard object* is the system clipboard that you know from all your
other Windows applications. It is the object that temporarily stores text or
graphics between applications. In the case of the Clipboard object, it has *3
important methods* that we will use:
- *Clear* empties the Clipboard.
- *SetText* puts the selected text into the Clipboard.
- *GetText* gets the contents of the Clipboard.
ExampleFor the purposes of this example, we will use the Registration Form
from Lesson 5.
We will add a Comment TextBox to the form. This textbox will be multiline,
with a vertical scrollbar. Then, we will add items to the menu to allow us
to edit the text entered in Comments. We want to be able to Cut, Copy, Paste
and Delete blocks of text.
To change the Menu, we again call upon the *Menu Editor*. We add the new
functions under the Edit item. To insert a *separator bar*, just put a
single hyphen in the Caption and give it a Name, mnu_sep1, for example. The
menu should look like this:
Then we code the menu events. Note that we use the Screen properties
exclusively in this example. Even if we are working in a control which is
called txt_comments, there is nothing in the code that refers specifically
to that control. We can copy this whole section to any form in any
application and it will work without a hitch.
Top <http://www.profsr.com/vb/vbless07.htm#Start>
Graphics When working with graphics (pictures, diagrams, images) the first
thing to master in the environment is the *coordinate system.* That is the
2-dimensional grid that defines locations on the screen in terms of (x,y)
coordinates. x is the horizontal position as measured from the left edge and
y is the vertical position as measured from the top. (0,0) is the upper
left-hand corner of the screen, form or other container.
By default, all VB measurements are in *twips*. A twip is 1/20 of a
printer's point (of which there are 72 per inch). Thus, there are *1440
twips in an inch, 567 in a centimeter*. The measurements refer to printed
size; because there are great variations between monitors, sizes may vary.
You can change the units of measure yourself by setting the *ScaleMode
property* for objects or controls.
*ScaleMode * *Meaning * 0 User-defined. 1 Twips - 1440 per inch.
2 Points
- 72 per inch. 3 Pixels - number per inch depends on monitor. 4 Characters
- character = 1/6 inch high and 1/12 inch wide. 5 Inches. 6
Millimeters. 7 Centimeters.
*Examples:
Me.ScaleMode = 5
*'sets scale to inches for this form
*pic_EmployeePic.ScaleMode = 3* 'sets scale to pixels for control
Adding PicturesYou can display pictures in 3 places in your application:
- On a form
- In a picture box
- In an image control
The *PictureBox* control and the *Image* control are very similar in
operation. However the PictureBox is more flexible in its methods and
properties and is the one you should use most of the time. There is little
use for the Image.
In all 3 cases you will display a picture contained in a graphics file
(.BMP, .GIF, .JPEG, .WMF, etc). The name of the file containing the picture
will be entered in the *Picture property *of the control or form.
In a form, the picture cannot be resized or moved, so it should be of the
correct size before you use it. The picture will serve as background and
other controls that you put on the form will be displayed over it.
The PictureBox's *AutoSize property* must be set to *True*, otherwise the
control's size will not change to accomodate the picture, as in the example
below.
In the above example the pictures were all added to the controls at design
time.
You can also insert or remove a picture at run time. You use the *LoadPicture
function*, as in: *pic_departmentlogo =
LoadPicture("C:\Pictures\acctnglogo.bmp")*
Removing the picture is done with the LoadPicture function without a file
name: *pic_departmentlogo = LoadPicture ("" )*
Drawing controlsThere are 2 controls in the toolbox which allow you to draw
directly on the form - the *Line control* and the *Shape control*.
Both are easy to use and fairly obvious. The main properties of each that
have to be manipulated are: *BorderColor* for the color of the line or shape
and *BorderStyle* to use a solid or dashed line.
In addition, the Shape control has: *Shape* for rectangle, circle, etc., *
FillColor* and *FillStyle* to determine how the shape will be filled and *
BackStyle* for transparent or opaque.
Top <http://www.profsr.com/vb/vbless07.htm#Start>
MultimediaMultimedia refers to devices other than the screen or the printer
to play sounds, watch videos or record music. This is done through the use
of the *Multimedia control*. Don't look for it in the toolbox, it's not
there. It is an additional control that you must load.
First, create anew form in Project Lesson7 and call it "multimed.frm". Then,
in the menu, at *Project --> Components*, find the item "*Microsoft
Multimedia Control 6.0*" and check the box next to it. Hit OK and that's it.
The Multimedia control should now appear in your toolbox.
If you select the multimedia control and put it down on the form, you will
have a button bar like all the ones you've seen on CD players, recorders,
etc. In the *DeviceType property* you specify what type of device this
control controls:
*DeviceType* *Device* CDAudio CD Audio player DAT Digital audio tape
player Overlay Overlay Scanner Scanner Vcr Videotape player and
recorder Videodisc Videodisc player Other Other devices not specified
Example: a simple CD playerWe create a new form in Lesson7 and call it
multimed.frm. After adding the Multimedia control to the toolbox, we put a
MM control on the form. Since we will only be using the one MM control,
we'll leave its name as MMControl1. The only property we have to change at
this time is the *DeviceType*, to tell it that we are using the CD player,
so we write CDAudio in DeviceType. We add a few labels to complete the form
and we get:
Now we have to write the code to operate the CD player.
Before we start to write the code there are a few things to know about the
MM control. There is a *Track property* which contains the number of the
current track. But its most important property is called the *Command
property* and it can take on several values that, in fact, operate the
device.
*Command value* *Meaning* Open Opens the device Close Closes the
device Eject Ejects the CD Play Plays the device Pause Pauses the
device Next Goes to next track Prev Goes to beginning of current track.
If used within 3 seconds of most recent Prev, goes to beginning of previous
track Record Initializes recording Save Saves the open device file Seek
Step backward or forward a track Stop Stops the device Step Step
forward through tracks
Understand that both Track and Command are run-time properties because they
are meaningless at design time. For example, to open the CD player:
*MMControl1.Command = "Open"* 'we assign the value "Open" to the
Command property
To pause:
*MMControl1.Command = "Pause"* 'we assign the value "Pause" to the
Command property
Now, as you have seen, the trick is to know with which events to associate
the code that has to be written. The first one is fairly obvious: when we
load the form, the *Form_Load event*, we will open the device. Now, one we
haven't used before. When we unload the form, we will close the device. The
reason is that, once launched, the device will keep on playing, even if the
form is closed. So, just click on the *Form_Unload event* and write the code
there. Finally, just to see that things are running smoothly, we will use
the StatusUpdate event for the MM control to display the track being played
every time the status of MMControl1 changes (change track, pause, play are
all status changes).
As you will see, once the CD starts playing, you can use the buttons in the
MM toolbar to control what it does.
You may notice that some of the buttons for the CD Player are not used
during play. If you want you can hide these buttons from the control by
using the *(Custom) property*. This will open an editor window that will
allow you to customize the MMControl.
------------------------------
Top <http://www.profsr.com/vb/vbless07.htm#Start>
Home <http://www.profsr.com/>
Tutorials<http://www.profsr.com/home3.html>
------------------------------
Jiyo cricket on Yahoo! India
cricket<http://us.rd.yahoo.com/mail/in/mailcricket/*http://in.sports.yahoo.co...>
Yahoo! Messenger
Mobile<http://us.rd.yahoo.com/mail/in/mailmobilemessenger/*http://in.mobile....>Stay
in touch with your buddies all the time.