Microsoft Corporation
July 27, 1999
Summary: This document will take you on a tour of the features contained in the Microsoft® Windows® CE Toolkit for Visual Basic® 6.0. You will learn how to create a simple application that is designed on a traditional Windows desktop and executed on a Windows CE device, and how to access data stored on a SQL Server™ 7.0 on a Windows NT® Server. (21 printed pages)
The following software applications must be installed on a machine in order to get the demo running:
In addition, the following hardware is required to run the demo:
This demo was written with a Windows NT 4.0 configuration (installed according to the instructions below) and a Sharp Mobilon Tripad H/PC Pro machine.
Set up the operating system of your choice as you normally would. Install Windows CE Services 2.2. Install all other software.
This guided tour requires the Northwind database found in Microsoft Office Professional or Premium Editions. Either Office 97 or Office 2000 will suffice. To find the database, open the "Find" dialog ("Start" -> "Find" -> "Files or Folders…", from the Windows Start menu) and search for "Northwind.mdb". Take note of the location of the Northwind database.
Figure 1. Locating the Northwind.mdb
With Windows CE Services 2.2, data copied to a Windows CE device will automatically be synchronized with the "master" copy of the data existing in an Access file or in a SQL Server.
To copy data from the parent machine to the Windows CE device, first establish a partnership and connect to the parent machine. For more information on how to do this, consult your Windows CE device documentation.
Once the connection is made, open the Windows Explorer and navigate to the Mobile Devices icon. Click on the connected device and import the required database tables.
Figure 2. Importing tables from Northwind.mdb
In the resulting dialog, select the Northwind Microsoft Access database you found earlier. Once the database is opened, a list of all tables is shown. After selecting the tables, the information is copied to the device and a synchronization relationship is kept.
Figure 3. Changing the database location
To turn off database synchronization, simply uncheck "Tables" in the ActiveSync options dialog ("Tools" -> "ActiveSync Options…" from the Mobile Devices folder).
Figure 4. Turning off database synchronization
With the Windows CE toolkits, developers can use the programming knowledge they have accumulated throughout their careers to build applications for a whole new class of devices and hardware. Windows CE is the next frontier of Windows development and allows businesses to extend their software development to whole new markets previously unavailable to them.
With Windows CE running on Web TV, businesses can build applications for a home consumer market that would otherwise be reticent about using a traditional personal computer. With Windows CE running on an AutoPC, developers can build truly mobile applications for fleets of salespeople, executives on the go, or consumers on the road. With Windows CE running on a handheld PC, developers can expand their opportunities to include non-traditional computer users who want simplicity and ease of management of above all else. Additionally, with Windows CE running on a palm-sized PC, programmers can take advantage of a data access device that allows anyone, anywhere, to access the information needed to run a business.
Because Windows CE development is as easy as traditional Windows development, these opportunities are available to developers today, with little additional training needed. The options are limitless, and because we are just at the beginning of this new phenomenon, developers have the entire spectrum of application development at their disposal. The "killer application" for Windows CE has yet to be discovered and developers who get in on the ground floor today will have a leg up on the competition in determining just what that killer application is.
This Guided Tour will help you create a complete data-driven application that can be copied and executed on a Windows CE device. For this demonstration, we will be using the Sharp Mobilon Tripad Handheld PC (H/PC) Professional Edition. However, any H/PC Pro will do.
Building a Windows CE application in Visual Basic doesn't involve any unusual steps at all. In fact, let's just go ahead and create a new project and see what it looks like.
You'll notice that in the New Project dialog there are several options to choose from. Some of these options are Windows CE Forms. When building a Visual Basic application, all you need to do is select one of these Windows CE Forms, drag and drop components, and add code just as you normally would. There's no special magic or incantations to build a Visual Basic application for a Windows CE device. All of the forms, as well as debugging tools and class libraries, are installed by the Windows CE Toolkit for Visual Basic 6.0. The Toolkit is essentially an add-on to the Visual Basic environment and, in fact, requires Visual Basic 6.0 Professional Edition or greater.
Once the template is selected, a project properties dialog will appear. In this dialog, you can specify all the information for how and where the project will be executed on the remote device or emulator. With all the rudimentary elements to application development, including form size, project location, and descriptive elements, the dialog will help you get up and running so that you can get to the important phases of application design and development.
For the purposes of this example, set the project's properties as shown in the dialog below.
Figure 5. Setting project properties
Press OK to move on to designing the form.
After the project properties are finalized, a Visual Basic Form will appear, allowing you to visually design your application. You will start out with a blank form, as shown below.
Figure 6. Visual Basic form
Now we will need to include all of the Windows CE-specific controls in our Toolbox by importing them from the on-system libraries.
Figure 7. Selecting components for the Toolbox
All of the components will now appear on the Toolbox and can be dragged and dropped from there onto the Form.
Our application will be a simple record lookup form that will allow us to select a customer and gather information about the customer. When designing the Form, we should keep in mind that the application will be run on a small device, with a moderately small screen (640 x 480 resolution). Further, many of the H/PC Pro devices have touch-screens, which can be activated either by a stylus or a touch of the finger. Therefore, we will make sure that all of our fonts are large enough to read and all buttons or sliders will be large enough to be manipulated by a finger, as well as a stylus. It is important to recognize the unique attributes of the devices for which you build applications.
We will design the Form by first placing a combo box on the Form as shown below.
Now we will need to flesh out the rest of the Form with Label and TextBox controls.
Figure 8. Setting the Name property of the TextBox control
In some cases, you may want to create more complex user interfaces using additional Windows CE ActiveX® controls. However, it is important to realize that not all of the functionality found on traditional Windows desktops is present in the Windows CE operating system.
Figure 9. Message for an unavailable control
As you can see, the Windows CE Toolkit for Visual Basic 6.0 helps you by telling when a control is unavailable on the Windows CE operating system. Because the Win32® API present on Windows CE is a subset of that found on traditional Windows desktops, the Windows CE Toolkits help tremendously by informing you of unsupported functionality.
Once the Form is complete, we need to set up an event handler so that we can update the customer information whenever a new customer is selected. One of the beauties of Windows CE development in Visual Basic is that there is very little difference between developing traditional Windows desktops and developing Windows CE applications.
To add an event handler to the Combo Box, go to the Code Editor and select "comboCustomerName" in the "Object" dropdown and "Click" in the "Procedure" dropdown. Visual Basic will automatically jump you to the Visual Basic Code Editor in the comboCustomerName_Click function:
Figure 10. Adding an event handler
With Windows CE and ActiveX Data Objects for CE (ADOCE), a Windows CE device can contain a local copy of a remote ODBC data source. When the Windows CE device is connected to the "parent" computer, the database tables are automatically synchronized. New information on the database server is automatically copied to the CE device's local store, and any information changed on the CE device is uploaded to the database server. With the obvious management simplicities of the Windows CE device, this is a perfect solution for task-specific applications.
ADOCE functionality can be found in a separate library that is installed by the Windows CE Toolkit. To import the library into the current project, go to the "Project -> References" menu and look for the "Microsoft CE ADO Control" component.
Figure 11. Importing ADOCE functionality
Once again, the programming models in developing applications for the traditional Windows desktop and the Windows CE device are very similar. We've already seen how building Visual Basic Form-based applications requires little additional training. Similarly, developing ADO applications for Windows CE is no more difficult than programming desktop applications.
We must first add a few global variables. The first two are strings, one representing the SQL statement that we will execute on the database, the other the physical location of the database on the device itself:
Once the global variables are added, we need to create a global variable representing the Recordset that we will manipulate. Add the following line of code:
Notice how Visual Basic's IntelliSense® technology continues to work, even when creating a Windows CE project. That's because the Windows CE Toolkit is an add-in to the traditional Visual Basic product, allowing you to take advantage of all the features in the world's most popular development environment while you build applications for Windows CE.
Figure 12. Setting up data access
Opening the database is as easy as it is in desktop development. First, we need to create the Form_Load() function. You can either hand-code the function or go to the "Object" dropdown and select "Form".
Once the Form_Load() function is available, allocate the Recordset object by adding the following lines of code inside the function:
The FillCustomers function is something we will create in a moment to populate the data in the combo box control.
Now we need to open the Recordset itself so that information can be extracted from it. Change to Form_Load() function to include the new line of code:
The Open method on the Recordset object accepts five parameters: the SQL string (which we already declared as a constant), the Database name and location (which we already declared as a constant), and three integers representing read/write capability and more. For more information on the ADO "Open" command, consult the ADO for Windows CE documentation.
We will need to create a FillCustomers function that will be called by the Form_Load() subroutine. The FillCustomers function is responsible for traversing the rows in the Customers table and extracting the appropriate information to place in the comboCustomerName dropdown.
The first thing we need to do in the FillCustomers function is to move to the first element in the Recordset. Next, we need to create a while loop that will help us traverse the Recordset with the end-of-file state as the condition:
Inside the while loop we need to add the name of the customer to the combo box and then move on to the next row in the Recordset:
Once a customer name is selected from the combo box, the "click" subroutine will automatically be called. Within the "changed" subroutine, we will need to search the Recordset for the name selected in the combo box. Once the record containing the name is found, we can use the rest of the data in the row to fill out the remainder of the Form.
First, we need to move to the first item in the Recordset. Next, we must once again create a while loop and add some code to search the tables for the specified name. When the name is found, we should break out of the loop. Otherwise, we should continue with the loop.
To complete the application, we must add code to update the text fields on the Form with the corresponding data in the Customers table. After the end of the loop in the comboCustomerName_Click function, we need to add the following four lines of code:
textAddress.Text = rsCustomers.Fields("Address").Value
textCity.Text = rsCustomers.Fields("City").Value
textState.Text = rsCustomers.Fields("Region").Value
textZIP.Text = rsCustomers.Fields("PostalCode").ValueAfter we are finished developing the Windows CE application, we must copy it to the remote device and execute it. With the Windows CE Toolkit for Visual Basic 6.0, deploying a Windows CE application is as easy as pressing the "start" button. The Toolkit will automatically copy the application (and any needed DLLs such as Tab Strip controls and more) to the device. Further, it will launch the application on the device for us.
Press the Start button on the Visual Basic main menu.
After doing so, the Visual Basic run time, the necessary DLLs, and any controls that have yet to be installed on the device are automatically copied.
After that process is complete, the application itself is copied.
The application should automatically start on the device.
Several Windows CE tools that enable you to go the distance with Windows CE software development are installed alongside the Windows CE Toolkits. The Windows CE Remote Zoomin application, for example, lets you take screenshots of a application as it runs on a remote device.
Figure 13. Windows CE Remote Zoomin
The debugger in the Windows CE Toolkit for Visual Basic 6.0 can be started by selecting the "Go" item from the "Debug" menu.
Figure 14. Starting the debugger
The debugger is a separate program that is launched after the "Go" menu item is selected. From within the debugger, you can set breakpoints, drag variables to the watch window, inspect the callstack, and more.
Figure 15. Inside the debugger
In order to set a breakpoint, you need to view the code inside the debugger application. In this release, setting a breakpoint in the Visual Basic code editor will not affect operation of the Windows CE debugger.
There are several more ActiveX controls for user interface design including tab controls, scrollbars, picture boxes, tree controls, and more. To use these controls, simply drag and drop them from the toolbox onto the Form.
In order to use the TabStrip control, you will need to create separate borderless Frame controls. When a specific tab is selected, you need to hide all Frame controls except the one corresponding to the selected tab.
For example, if we were to drag and drop a TabStrip control and add three tabs to it: "New Order", "Order History", and "Web", we would need to add three corresponding Frame controls for each: fraNewOrder, fraOrderHistory, and fraWeb.
Figure 16. Dragging a TabStrip control onto the Form
Figure 17. Adding tabs to the control
Now you need to drag and drop some Frame controls onto the Form, make them borderless, and position them on the Tab control.
Figure 18. Resizing the Frame control
You can drag and drop controls onto the individual Frame controls. The controls will become "children" of the Frame control, so whenever the Frame control is hidden, the controls placed on it will be hidden as well. In order to select a specific Frame, go to the Properties sheet and simply select it in the controls list dropdown:
Figure 19. Selecting a frame
Because all the Frames overlap one another, you will need to use the "Order" menu item (shown below as part of the "Format" menu) to bring a Frame to the foreground so that you can drag and drop controls onto it.
Figure 20. Bringing a frame to the foreground
Now that the frames are on the Form, we need to set up the logic so that when a specific tab is selected, the appropriate Frame control is shown. All we need to do is add some code into the TabStrip control's click method that determines what tab was selected and shows the correct Frame control.
Windows CE introduces a new kind of user interface element called a CommandBar. The CommandBar is a special menu bar that hosts not only traditional menu items, but command buttons and combo boxes as well. The CommandBar control replaces the main title bar of the Form.
Since the CommandBar control replaces the Form's title bar, we will need to remove all borders from the Frame itself. Then, simply drag and drop the CommandBar control onto the Form. While the control can be placed anywhere on the Form, when the application is run, the CommandBar will become the new title bar for the Form.
Figure 21. Dragging and dropping the CommandBar control onto the form
To add controls to the CommandBar, use the Add method of the CommandBarControls collection. Once you add member controls to the CommandBar control, the CommandBar reacts to user input by generating events. A CommandBar control generates a specific event for each type of member control. For example, when a user selects any CommandBarButton object, the control fires the ButtonClick event. You therefore must code the event to determine which particular CommandBarButton object was selected by the user.
You can add the following types of object to your CommandBar control:
For example, adding a menu to the CommandBar control involves first creating the CommandBarMenuBar object and then adding it to the Controls collection of the CommandBar control.
Then, adding the actual menus is as easy as creating the menu object, and adding elements to it.
The Windows CE Toolkit for Visual Basic 6.0 documentation includes more sample code for using the CommandBar control.
There is no specific event handler for the individual menu items. Instead, you must use the MenuClick event handler of the CommandBar control and parse the Key property for the correct sub-menu item:
Using the Windows CE Toolkit for Visual Basic 6.0, you can take advantage of the world's most popular development tool and use your existing skills to build and deploy compelling applications for the next generation of computing devices.