Microsoft C# Express Starter Kit

Starter Kit: My Items Tracking Application

Contents:
 Introduction
Installing the Starter Kit
Running the Sample Application
Application Design
Getting Started Building Your Own Version
Advanced Functionality
What's Next
For More Information

 

Introduction

The My Items Tracking Application Starter Kit is a sample application for keeping track of things --- pictures, coins, stamps, addresses, anything you want.  It has a simple user interface for presenting the items, adding new items, and deleting existing items.  The data is stored in a SQL Server 2005 database.  Here's a snapshot of the application's main window, which is tracking a few of my favorite pictures:

The starter kit provides you with a framework for creating this application.  We'll provide the database and a template for the main form.  You'll add the user interface elements and the code to bring the application to life.  Enjoy!

 

Installing the Starter Kit

If you are reading this tutorial, the starter kit should have already been installed in your local user account via the provided Microsoft installer (.msi) package.  If you haven't already, you need to download and run the .msi package before continuing.

After installation, two components are copied to your local user account:  (1) this tutorial plus a sample application for you to experiment with, and (2) a Visual Studio 2005 template for creating your own version of this application.  Both components are stored locally in your My Documents folder.  The second component is stored as a .zip file in My Documents\Visual Studio 2005\Templates\ProjectTemplates\Visual C#\Starter Kits\.  By default, the first component is installed in My Documents\Visual Studio 2005\Starter Kits\C#, in a folder named "My Items Tracking Application".  Here's a snapshot of what that folder will look like (the address displayed contains my username "hummel", your address will differ):

The Database folder contains a backup copy of the underlying database you'll be using, in case you ever need a fresh copy.  The Documentation folder contains this tutorial.  The EXE folder contains a sample Items Tracking Application for you to run and experiment with; more on that in the next section.  Finally, the Solution folder contains the complete source code to the sample application.  No need to look at that now, you're going to be building it yourself soon enough!

 

Running the Sample Application

Before we start building the application, let's get a feel for the task at hand by running the sample version.  Go ahead and open a File Explorer window to the installed "My Items Tracking Application" folder mentioned earlier.  In other words, view the contents of the folder My Documents\Visual Studio 2005\Starter Kits\C#\My Items Tracking Application.  As discussed above, you'll see:

Go ahead and open the EXE folder, and you'll find the following 4 items:

This is a self-contained version of the completed application (if you don't see the file extensions such as ".mdf" and ".config", please select Folder Options from the Tools menu, switch to View tab, and uncheck the option "Hide extensions for known file types").  The .mdf and .ldf files together represent the underlying SQL Server 2005 database used by the application for storing items.  The .exe file represents the executable application itself, and the .config file configures .NET for proper execution.  This application can be run on any computer with the following software installed:  (1) SQL Server 2005 Express Edition, and (2) .NET Framework 2.0.  These were installed when you installed Visual Studio 2005; in general this software is freely available from (1) http://msdn.microsoft.com/vstudio/express/sql/ and (2) Windows Update.

Take a few minutes to run and familiarize yourself with the application.  To run, double-click on the executable file Recipe_1._3.exe (shown above with the file cabinet icon).  Resize it, add new items, delete items, and get more information about the application from the Help menu.  This is the exact application you are going to build!  The goal of this starter kit is to help you produce your own double-clickable version using Visual Studio 2005.

 

Application Design

Before we start developing the application, let's first talk about its design.  This is a data-driven application, meaning there is a database (or some data source) for accessing and maintaining the underlying data.  In our case we are using a SQL Server 2005 database named ItemsDatabase.  Here's a diagram summarizing the high-level design:

The other important design component is that of the database itself.  If you are familiar with relational databases, read on --- if you are not, no worries, simply skip this paragraph and you can get started that much sooner :-)  The ItemsDatabase contains a single table named Items_Table, shown here:

Each item in the database translates into one row in this table.  As a result, each item has 4 fields of information:  id number, name, description, and image.  The first field is named IID_PK, which stands for the Item ID Primary Key.  This is a long (64-bit) integer that uniquely identifies the item in the database; when items are added to the database, the value of this field is automatically assigned by SQL Server.  The second field is named Name_F, which stores the name for the item; this can be up to 64 characters in length.  The third field is Description_F, which stores an arbitrarily-long string of information about the item.  The fourth and final field is Image_F, which stores an image of the item; this field is optional. 

 

Getting Started Building Your Own Version

To get started, open Visual Studio 2005 and create a new project:  File menu, New, Project... .  A dialog window will appear allowing you to select the type of project you want to create.  Under "Project types", expand Visual C#, and click on Starter Kits.  You will then see something like the following in the Express edition of Visual Studio 2005:

[ If you are using a different edition of Visual Studio 2005, the dialog will look more like this. ]  Change the Name text field to "ItemsTrackingApplication", and click the OK button when you're ready.  Visual Studio will create a new application skeleton based on the template, and display a Solution Explorer window that looks as follows:

You're ready to go!  [ If you do not see a Solution Explorer window, use the View menu to make it visible; the Solution Explorer is key to navigating among the various components of your application within Visual Studio. ]

Let's start by building out the application's main form.  Double-click on the icon in the Solution Explorer for FormMain.cs, and this will open the form in design mode.  You should see a blank form appear in Visual Studio:

Even though we haven't done anything yet, run the application by pressing F5.  When the app runs, notice the main form is automatically created, displayed in the center of the screen, and its title bar is set to "Items Tracking Application".  You can resize the form, move it around on the screen, etc.  Go ahead and minimize the main form --- the application is still running, which is confirmed by Visual Studio's title bar displaying the text "(Running)".  To stop the application, you can use Visual Studio's Debug menu, click the Stop button on Visual Studio's toolbar, or normalize the main form and close it via the X in the top-right corner.  Once you stop the application, notice that Visual Studio no longer displays "(Running)" in the title bar.  Visual Studio is now back in design mode.

The initial state of the main form is controlled through its properties, displayed by clicking on the form in design mode and then viewing the contents of the Properties window.  The Properties window is normally displayed on the bottom-right in Visual Studio; use the View menu if window is not visible.  The following properties were set for you: (Name), Font, Icon, Size, SizeGripStyle, StartPosition, and Text. 

1) Adding the Menu Bar

The first step is to add a menu bar to the application, with File and Help menus.  Hover your mouse over the Toolbox, which in design mode appears to the left of the main form's title bar.  The Toolbox houses user interface controls for building form-based applications, for example buttons, text boxes, and menu strips.  Find the MenuStrip control in the Toolbox (you may need to scroll), click to select, hold the mouse down, drag over to the main form, and drop onto the surface of the form.  An instance of the control named menuStrip1 should appear below the main form in the Application Tray, and the start of a menu bar should appear on the form itself.  Type "&File" (without the ") into the newly-created menu area (where it says "type here"), press ENTER to record your entry, and then enter the menu items under the File menu:  "&Add...", "&Delete...", "-", and "E&xit".  The "&" character denotes the Windows accelerator key for this menu item, e.g. Alt-F will now trigger the File menu; the "-" denotes a menu divider. 

Once you have the File menu designed, create a "&Help" menu to the right of the File menu, with a single menu item named "&About...".  When you are done, click on the surface of the form to close the menu designer.  Press F5 to run the application, and play around with the menu bar; convince yourself the accelerator keys work, e.g. Alt-F and Alt-H.

Stop the application and return to design mode.  Let's write some code!  In particular, when the user selects File >> Exit, let's programmatically close the main form and thereby stop the application.  Click on the File menu to drop the menu, then double-click on the Exit menu item to reveal the code-behind window.  Visual Studio will stub out the Click event method that will be called when the user selects File >> Exit.  Code this method to close the main form by calling this.Close().  When you are done, your method should look like this:

private void exitToolStripMenuItem_Click(object sender, EventArgs e)

{

    this.Close();

}

Run the application (F5) and test your handiwork.  Ignore the remaining menu items, we'll come back to those a little later. 

2) Building Out the User Interface

At this point we're going to flush out the main user interface for displaying items to the user.  This includes a ListBox control for listing the items, a TextBox control for displaying the current item's description, and a PictureBox control for displaying the current item's image (if any).  We'll also associate Label controls with each of the user interface elements so their purpose is clear.  Recall that the final product should look like this:

Back in Visual Studio, view the main form in design mode; when in doubt, double-click on the icon for FormMain.cs in the Solution Explorer.  Now hover over the Toolbox to reveal, then drag-and-drop a ListBox control onto the main form.  In the Properties window, set the following properties of the ListBox:

The (Name) property is perhaps the most important, since it denotes the programmatic name we'll use when programming this instance of the ListBox control.  The 3-letter prefix "lst" is a standard naming convention for ListBox objects.  Now, back in the Toolbox, drag-and-drop a Label control so we can label the ListBox for the user.  After you drag-and-drop, set the following properties of the Label via the Properties window:

To the right of the ListBox is a TextBox and a PictureBox (and 2 more Labels).  Drag-and-drop a TextBox control from the Toolbox onto the main form, and set the following properties via the Properties window:

The prefix "txt" stands for TextBox, and we set Multiline to true so the user can enter a longer description.  The ReadOnly property is set to true to prevent the user from accidentally editing the description; TabStop is set to false since there's no reason to stop here when the user is tabbing around the form (why stop if the user cannot edit the information?).  Next, drag-and-drop a PictureBox control, and configure its properties as follows:

The PictureBox is used to display an image of the item (if available).  Since images can come in many different resolutions, we set the control's SizeMode property to StretchImage in order to stretch or shrink the image to fit the size of the control.  While it may look funny at times, the image is never cut off nor too small to see.  Finally, drag-and-drop 2 Label controls, and move them into position above the TextBox and PictureBox as shown.  Change their Text properties to "Description:" and "Image:" respectively, and set their Font property to make the text appear in boldface.

Go ahead and run the application (F5); nothing will happen (i.e. the controls will remain empty), but you can at least check to make sure their layout looks reasonable.  Now it's time to hook the application up to the database!

3) Binding the ListBox to the Database

Okay, now for the really fun part --- connecting the database to the application.  What we're going to do first is connect Items_Table in the database to the ListBox, and display the names of all the items in the database.  In .NET terminology, we're going to data-bind the Name_F field of Items_Table to the ListBox.  Here's what you want to do to connect to the database:

  1. Reveal the Toolbox, and drag-and-drop a BindingSource control onto the main form (you may need to scroll down to the Data section of the Toolbox).
  2. An instance named bindingSource1 will appear below the main form in the Application Tray.
  3. Make sure bindingSource1 is selected (single-click on it to make sure), then view the Properties window.  Click on the DataSource property, then click on the down arrow that appears.  Click the + to expand "Other Data Sources", then click the + to expand "Project Data Sources", and select ItemsDatabaseDataSet.
  4. Now click on the DataMember property, click the down arrow that appears, and select Items_Table. 
  5. Finally, in the Sort property type "Name_F" (without the ") and press ENTER to record your entry.

You'll notice that the Application Tray now contains two more objects, itemsDatabaseDataSet and items_TableTableAdapter.  What we have just done in the 5 steps above is configured .NET to read the ItemsDatabase at startup, filling an in-memory data structure called a DataSet.  The next step is to bind this DataSet with the controls for display purposes.  First the ListBox:

  1. Click on the ListBox to select it.
  2. View the Properties window, click the DataSource property, click the down arrow that appears, and select bindingSource1. 
  3. Now click the DisplayMember property, and select the field of data to display in the ListBox --- Name_F.

That's it!  Press F5 to run, and the items in the database should now be listed in the ListBox!  (It may be a little slow the first time you run, as SQL Server Express needs to be started.)  In the given test database, you should see 3 items:  "Test item 1", "Test item 2", and "Test item 3". 

4) Binding the TextBox and PictureBox to the Database

When the user selects an item in the ListBox, this item becomes the "current" item.  If we data-bind the TextBox and PictureBox to bindingSource1, they will display the description and image of the current item.  First the TextBox:

  1. Click on the TextBox to select it.
  2. View the Properties window, and find the (DataBindings) property --- scroll to the top of the properties.  Click the + to expand (DataBindings), click on the Text sub-property, and then click on the down arrow that appears.
  3. A small window appears when you click the down arrow.  In the window, click the + to expand bindingSource1, and then select Description_F to display the item's description.

Press F5 to run, and click on the different items in the ListBox; the description should change accordingly.  Let's finish by data-binding the PictureBox:

  1. Click on the PictureBox to select it.
  2. View the Properties window, find the (DataBindings) property, cick the + to expand (DataBindings), click on the Image sub-property, and then click on the down arrow that appears.
  3. In the window that appears, click the + to expand bindingSource1, and then select Image_F to display the item's image (if any).

Press F5 to run, and select the 3rd item in the list --- a picture of a Dalmation should appear.  Good work, you have built a real data-driven application!

5) Resizable Forms

There's one flaw we need to fix...  Run the application, and resize the form.  Or maximize it.  Oops, the controls do not properly expand or contract.  The good news is that for most applications, this is easily fixed.  The idea is to "anchor" the resizable controls to the edges of the form, of which there are four:  Top, Bottom, Left, and Right.  As a particular edge moves, the control can be configured to move with it.  In particular, we need to configure the ListBox, TextBox, and PictureBox, as follows:

Press F5 to run the application --- resizing should work properly, as well as maximize and minimize.  Now we have a real Windows application!  This would be a good time to take a break if you haven't already.

 

Advanced Functionality

To make the application fully-functional, we need to add three more features.  These correspond to the three menu commands we have not yet implemented:  Help >> About, File >> Add, and File >> Delete.  Note that if you get stuck or need a hint when working on these features, there is a solution provided with complete source code:  see the _Solution sub-folder where you created your Visual Studio project.

1) Help >> About Menu Command

Most Windows applications have a Help menu with an "About..." command for getting more information about the application.  This functionality is straightforward to include, thanks to a built-in form template in Visual Studio.  In the Project menu of Visual Studio, select "Add Windows Form...".  A dialog window will appear.  Click on the template for an "About Box", and then enter FormAboutBox in the Name text field.  Click Add, and a new form named FormAboutBox.cs will appear in the Solution Explorer.

Next, let's program the Help >> About command to show this form when selected by the user.  Much like we did earlier when we implemented File >> Exit, the first step is to view the main form in design mode; when in doubt, double-click the icon for FormMain.cs in the Solution Explorer.  Then select the Help menu on the main form to drop it down, and then double-click on the About... menu item to reveal the code-behind window.  Visual Studio will stub out the Click event method that will be called when the user selects Help >> About.  Code this method to create an instance of FormAboutBox, and then show it by calling the form's ShowDialog() method.  Here's what your method should look like:

private void aboutToolStripMenuItem_Click(object sender, EventArgs e)

{

    FormAboutBox frm;

 

    frm = new FormAboutBox();  // create an instance of the About Box

    frm.ShowDialog();          // Show it as a dialog (user must dismiss before continuing)

}

The form is shown as a dialog (also known as a "modal" window) so that the user is forced to read and then dismiss the window before doing anything else in the application.  Press F5 to run the application, and test the Help >> About command.  A nice-looking About Box should appear, populated automatically with application information:

However, notice the "Written by" text is set to "???".  Let's fix this by inserting your name.  The About Box is driven by properties of your application, e.g. the version #, copyright info, and description.  To set these properties, first stop the application if it is still running.  Then, in the Project menu of Visual Studio, select the command at the very bottom of the menu:  "Recipe_1._3 Properties".  Click on the Application tab, and then click the "Assembly Information..." button.  A window will appear, and you'll see the version #, copyright information, and company information --- which is currently set to "Written by ???."  Change the Company text field to include your name, set any others you might be interested in, and then save your changes via the File menu.  Press F5 to build and run the application, and view your application's About Box via the Help >> About... command.  Your name should now appear!

2) File >> Add... Menu Command

A fully-functional tracking application should allow the user to add items to the database.  This consists of two main steps:  (1) collecting the necessary information from the user, and (2) inserting this information into the database.  To aid you with step (1), a form for collecting info from the user has already been written for you, and included.  This is the purpose of FormAdd.cs in the Solution Explorer.  Go ahead and double-click the icon for this form to view it in design mode:

There's nothing you need to add to this form, it is completely implemented and ready for use.  What needs to be done is the implementation of the File >> Add... menu command.

View the main form in design mode; when in doubt, double-click the icon for FormMain.cs in the Solution Explorer.  Then select the File menu on the main form to drop it down, and then double-click on the Add... menu item to reveal the code-behind window.  Visual Studio will stub out the Click event method that will be called when the user selects File >> Add.  For starters, let's code this method to create an instance of FormAdd, and then show it by calling the form's ShowDialog() method.  However, what we're also going to do is figure out which button the user clicked to close FormAdd --- was it Add or Cancel?  Here's how you want to code the method:

private void addToolStripMenuItem_Click(object sender, EventArgs e)

{

    FormAdd frm;

    DialogResult result;

    //

    // Create and show form to user for adding new item:

    //

    frm = new FormAdd();

    result = frm.ShowDialog();

    //

    // Did user cancel, or click ok?

    //

    if (result == System.Windows.Forms.DialogResult.Cancel)

        MessageBox.Show("Add cancelled...", "Tracking Application", MessageBoxButtons.OK, MessageBoxIcon.Information);

    else

        MessageBox.Show("Item added to database!", "Tracking Application", MessageBoxButtons.OK, MessageBoxIcon.Information);

}

Run the application (F5), select the File >> Add command, and make sure an instance of FormAdd appears.  Then type in a name for the new item, and click the Add button.  Does the appropriate Message Box appear?  Repeat, but this time click the Cancel button --- correct Message Box?  Unfortunately, nothing is really being added to the database, since FormAdd merely collects the information.  Inserting the information into the database is our job.

Okay, now that we have step (1) working, let's focus on step (2):  inserting the new item into the database.  The idea is to (a) retrieve the information entered by the user into the instance of FormAdd, (b) insert the information into the database, and then (c) update our application's in-memory copy of the database.  What we want to do is modify the Else part of the Click event method shown above so that it performs these three steps.  Here's the code, with comments for explanation:

    else

    {

        //

        // user clicked ok, so add new item to the database:

        //

        string name, description;

        byte[] image;

        //

        // (a) Retrieve item data from sub-form:

        //

        name = frm.ItemName;

        description = frm.ItemDescription;

        image = frm.ItemImage;

        //

        // (b) Okay, we're ready to add the new item to the database:

        //

        this.items_TableTableAdapter.Insert(name, description, image);

        //

        // (c) Now refill the dataset (our local in-memory copy):

        //

        this.items_TableTableAdapter.Fill(this.itemsDatabaseDataSet.Items_Table);

 

        MessageBox.Show("Item added to database!", "Tracking Application", MessageBoxButtons.OK, MessageBoxIcon.Information);

    }//else

Okay, time to run and test!  Press F5 to run, and trying adding an item to the database without an image.  Once added, it should appear in the ListBox, and selecting it should display the correct description.  Now repeat, but trying adding an item with an image; once added, viewing the item should display the proper description and image.  Finally, be sure you can cancel out when adding an item, and make sure the database is not updated. 

Stop the application, then run it again.  Anything you added to the database should still be listed.  Good work!

3) File >> Delete... Menu Command

The final feature to support is the deletion of items from the database.  While this feature is not absolutely necessary, it's good to provide a way for the user to remove outdated or unwanted items from the database, such as the three test items in the sample database.  In this case the user will select an item in the ListBox, and then select the Delete... command from the File menu.  We'll ask the user to confirm the deletion, and if he/she concurs, we'll (a) remove the item from the database and then (b) update our application's in-memory copy of the database. 

The one complication is that in order to delete an item from the database, we need to uniquely identify that item.  This is the purpose of the IID_PK field in the database, which contains a unique id number for identifying each item (in database terminology, the IID_PK field is known as the record's primary key).  The implication is that in order to delete the selected item, we need the value of that item's IID_PK field.  Unfortunately, this value is currently not available.  The good news is that this is easily corrected.

Since there's no reason for the user to see the IID_PK value, what we're gong to do is data-bind the IID_PK field to a hidden property of the ListBox.  This way, when it comes time to delete an item, we can look in the hidden property to retrieve the necessary IID_PK value and remove the correct item from the database.  To setup the data-binding, do the following:

  1. View the main form in design mode, and single-click on the ListBox to select it.
  2. Click on the + to expand the (DataBindings) property, click on the Tag property, and click on the down arrow that appears.
  3. In the small window that appears, click the + to expand bindingSource1, and then select IID_PK.

Okay, now we're ready to start programming the File >> Delete menu command.  View the main form in design mode, select the File menu on the main form to drop it down, and then double-click on the Delete... menu item to reveal the code-behind window.  Visual Studio will stub out the Click event method that will be called when the user selects File >> Delete.  Let's start by coding the method to check that an item is selected, and if so, retrieve the item's name and primary key:

private void deleteToolStripMenuItem_Click(object sender, EventArgs e)

{

    //

    // is an item selected for deletion?

    //

    if (this.lstItems.SelectedIndex < 0) // nothing selected, tell user to select something first:

    {

        MessageBox.Show("Please select an item for deletion...", "Tracking Application", MessageBoxButtons.OK, MessageBoxIcon.Error);

        return;

    }

    //

    // ok, we have a selected item, we need the item's primary key and name for deletion. Note that the primary key is

    // data-bound to the listbox's Tag property for just this purpose.

    //

    long iid;     // retrieve IID_PK from Tag (as a string), then convert to what we need (long integer)

    iid = System.Convert.ToInt64(this.lstItems.Tag);

 

    string name;  // retrieve Name_F from the Text of the selected item

    name = this.lstItems.Text;

 

    // Popup a temporary message box with name & primary key for testing purposes:

    MessageBox.Show("Deleting: " + name + ", " + iid);

}

Go ahead and run the application (F5), select an item, and delete it --- we aren't actually deleting anything, just popping up a Message Box to display information about the item to be deleted.  In particular, we are displaying the item's name and primary key to make sure things are working properly.  As a test case, if you select "Test item 1" for deletion, your application should display an IID_PK value of 1.

When you're ready, delete the last line (i.e. the MessageBox.Show statement), and replace it with the following block of code:

    //

    // confirm deletion:

    //

    DialogResult result;

    string msg;

   

    msg = "Are you sure you want to delete item '" + name + "'?";

    result = MessageBox.Show(msg, "Tracking Application", MessageBoxButtons.YesNo, MessageBoxIcon.Question);

    if (result == System.Windows.Forms.DialogResult.No)  // user changed their mind, abort!

        return;

    //

    // (a) ok, go ahead and delete from underlying database:

    //

    this.items_TableTableAdapter.Delete(iid, name);

    //

    // (b) now refill the dataset (our local in-memory copy):

    //

    this.items_TableTableAdapter.Fill(this.itemsDatabaseDataSet.Items_Table);

 

    MessageBox.Show("Item deleted.", "Tracking Application", MessageBoxButtons.OK, MessageBoxIcon.Information);

This code starts by confirming the deletion, and aborts if the user selects No.  However, if the user confirms the deletion, we (a) remove the item from the database and then (b) update our application's in-memory copy of the database.  Run the application (F5) and test by deleting an item but then cancelling the deletion --- no change should be made to the database.  Repeat, but this time confirm the deletion --- the underlying database should be updated.  To convince yourself that that database has in fact been modified, stop the application, and then run it again.  Whatever you deleted from the database should no longer be listed.

That's it, you now have a fully-functional, data-driven Windows application.  Excellent work!

 

What's Next

If you've completed this tutorial, you have produced a fully-functional, data-driven Windows application.  You might even want to use this application to keep track of things.  If you do, let's find the executable application (.EXE) that you built with Visual Studio.  Locate the project folder for your Items Tracking Application.  If you are using the Express edition of Visual Studio 2005, your project folder will be in My Documents\Visual Studio 2005\Projects; in other editions of Visual Studio 2005 you specified the location when you created the project from the Starter Kit template.  The folder will look as follows (assuming a location of D:\Temp):

Open the Recipe_1._3 sub-folder, then open the bin sub-folder, and finally the Debug sub-folder.  You will see something like the following:

Your application is the first four files you see listed:  ItemsDatabase.mdf, ItemsDatabase_log.ldf, Recipe_1._3.exe, and Recipe_1._3.exe.config (if you don't see the file extensions such as ".mdf" and ".config", please select Folder Options from the Tools menu, switch to View tab, and uncheck the option "Hide extensions for known file types").  If you copy these four files to another folder, you now have a double-clickable Windows application for tracking items.  If you want to track another set of items, simply make a copy of this folder. 

Extensions to the application?  It would be helpful if the database contained the date when the item was added, and if the application displayed this date.  This will take a bit of work, since you'll have to modify the underlying database, update the corresponding database schema definition ItemsDatabaseDataSet.xsd, add another control for displaying the date, data-bind this control to the database, and modify how items are added to the database to include the current date. 

That's it, we hope you have enjoyed this tutorial, and learned a few things about .NET, C#, and Visual Studio 2005.  Good luck!

 

For More Information

For more information, checkout these web sites:

© 2000 Microsoft Corporation and/or its suppliers. All rights reserved. Terms of Use.