Visual Basic Free Tutorial

Web based School

Chapter 21

Visual Basic and ActiveX

Look in a guidestore and you'll find many thick guides that discuss ActiveX. ActiveX is Microsoft's new open technology that is supposed to merge the desktop with the Internet seamlessly. Although that lofty goal is probably thrown around too lightly today, it's true that ActiveX takes component technology a step forward. Although Visual Basic programmers have been used to drop-in controls since Visual Basic's version 1.0, ActiveX controls give programmers on all PC development systems similar abilities and the controls can communicate with each other and with applications without regard for the development language being used.

This lesson, being only an hour long, can only expose the tip of the ActiveX iceberg. Nevertheless, by the time you finish this lesson, you will have a better idea of what ActiveX is, how Visual Basic supports ActiveX, and how ActiveX takes its predecessors, OLE and custom controls, to their next step.

The highlights of this hour include

  • Why ActiveX controls are important today

  • Where ActiveX controls come from

  • How to install ActiveX controls in your Toolbox window

  • What you need to create ActiveX controls

  • How to bring OLE objects into your application

  • How to convert a form to an ActiveX document

ActiveX: The Tools You Use

In Hour 12, "Dialog Box Basics," you learned how to add the Common Dialog Box control to Visual Basic's Toolbox window. In Hour 19, "Toolbars and More Graphics," you added additional tools to produce a toolbar and an image list. The tools that you added are examples of ActiveX controls.

New Term: An ActiveX control is a control you can add to Visual Basic's Toolbox window. If the Toolbox window does not contain the control you need, you might find an ActiveX control that suits your purpose and you can add that control to the Toolbox window for use in your application.

All the controls you find in Visual Basic's Project | Components dialog box (shown in Figure 21.1) are ActiveX controls. Search through the dialog box now to locate controls that interest you. You may never use all of the controls, but some you'll use many times (such as the Toolbar control).

Figure 21.1. Visual Basic comes with many ActiveX controls.

Locating ActiveX Controls

As you look through the controls, you'll find a Marquee control that displays moving text across a form, a Calendar control, a Charting control, a Modem communications control, and several others, including some Internet controls you'll read about in this guide's final lesson. By the way, all the Internet controls also work for intranets, the intracompany networked Internet connections so much in use today. When you add many of the controls, such as the marquee control, to your Toolbox window, you can probably figure out which properties to set from the Properties window, but the majority of the controls support too many esoteric properties, events, and methods for you to figure all of them out without help. Visual Basic's guides Online reference describes these additional ActiveX controls so you can get help with a control when you need help. The Components dialog box is not the only place you'll find ActiveX controls. If you click the Component dialog box's Browse command button, you can search your hard disk for other controls. If, for example, you subscribe to the Microsoft Network online service, your Microsoft Network folder will contain some ActiveX controls you can use. Many vendors sell ActiveX controls and you can search Microsoft's Web site for additional information. Many online services and Internet pages offer free or shareware ActiveX controls that you might want to try as well. Search the Internet using some of the search engines available for a list of ActiveX sites.
Previous versions of Visual Basic supported these extra controls, but Visual Basic used to work only within a 16-bit environment. Therefore, the tools the Visual Basic programmers used were 16-bit tools called VB custom controls. A custom control, therefore, was a control you added to your Visual Basic Toolbox window to gain additional power.

As the need for tools grew and as other programming platforms, such as Visual C++, began requiring such extra tools, these other platforms began supporting the use of VB custom controls. Therefore, if a Visual C++ programmer wants a Text Box control, the Visual C++ programmer had to locate a Visual Basic Text Box control file and add the text box to Visual C++'s development environment. (Those C++ programmers are always playing catch-up to Visual Basic programmers!)

NOTE: The 16-bit VB custom controls use .VBX for their filename extensions. Visual Basic version 5 can no longer use these 16-bit controls because version 5 supports only 32-bit controls.

New Term: Encapsulation refers to a package of data and code that works like a small program. A control is encapsulated.

Soon, shortcomings of the VB custom controls began surfacing and their capability for taking advantage of new technology, such as 32-bit operating environments, became obvious. Microsoft developed a new control standard called OCX controls. One of the nice things about VB custom controls was their capability to work between and inside several programs even if the programs that used them were not Visual Basic programs. The controls were encapsulated so that the programming language only needed to know the properties, methods, and events supported by the controls to use the controls. The OCX controls, called that because of their .OCX filename extensions, kept all of the 16-bit controls' advantages but also worked inside the 32-bit environment.

New Term: OLE (short for object linking and embedding) refers to the process of inserting linked and embedded objects in one application that another application created.

All along the way, the distinction between OLE and these OCX controls became blurred. An OLE process used a custom control to do its job and the OCX controls further refined the OLE process so that a programmer could embed a complete application written in Visual Basic inside a Visual C++ program. In addition, the user could even drag an Excel worksheet into a Word document, and that worksheet not only became another data item inside the document, but the worksheet was active; when the user clicked the worksheet Excel's menus appeared in place of Word's. That Excel worksheet was nothing more than an advanced OCX control.

ActiveX controls are OCX controls that take these drag-and-drop and drop-into-code concepts even further. An ActiveX control can appear on a Web page (if the page is ActiveX enabled and the user's browser is also; most Web browsers are ActiveX enabled today) for anyone to use. In other words, if a Web page contains an ActiveX control, even if that control is a complete Visual Basic application turned into an ActiveX control (no size limitation for controls exists), the users who view the Web page see the application and interact with it as if they were running it from their own hard disk. ActiveX controls took the concept of OCX controls to the Internet. Now, if you want a special tool such as a command button on your Web page, you can just place an ActiveX command button control on the Web page during the page's development, and your page's users will be able to click the command button.

NOTE: Microsoft seems to be making a push for all code to be these kinds of ActiveX controls. Future operating systems are supposed to be ActiveX based. All programs will, in effect, be ActiveX controls. Therefore, you can embed any application within any other and borrow technology instead of reinvent it. Future programming, in theory, will involve building and combining prewritten ActiveX controls.

Don't throw out your Visual Basic programming language skills just yet, however. The ActiveX control as a total solution is still theory and is only partially available and working today in reality. Your Visual Basic skills are not only going to be needed in the future as ActiveX controls gather steam, but your Visual Basic programming skills are going to be needed even more as companies retool their applications and turn applications into such controls.

The VB Custom Control Edition

The Visual Basic 5 Custom Control Edition lets you build your own ActiveX controls.

If you use Visual Basic's Professional or Enterprise Editions, you not only have Visual Basic, but you also have the ability to create ActiveX controls. Both editions come with the VB 5 Custom Control Edition. Therefore, if you like command buttons but you wish they would support a special event or property your application needs, you can write your own command button control, as an ActiveX control, and then use that control as if Visual Basic came with it. You can add the control to your own application's toolbox (through the Project | Components dialog box) and set its properties from the Properties window.

Do You Use VBs Standard Edition?

Here's the really neat thing if you don't use the Professional or Enterprise Edition but use the Standard Edition: This guide's CD-ROM comes with the complete VB 5 Custom Control Edition. You'll have exactly the same ActiveX control-building utility that the other guys have. Professional and Enterprise Edition programmers can enter the VB 5 Custom Control Edition utility from within their development environment, as you're about to see. You simply have to exit Visual Basic and start this guide's supplied VB 5 Custom Control Edition program that you can install right alongside Visual Basic on your hard disk.

To build an ActiveX control, you must begin by starting the VB 5 Custom Control Edition by creating a new project and selecting the ActiveX Control icon. The VB 5 Custom Control Edition screen looks a lot like Visual Basic's screen, as Figure 21.2 shows.

Figure 21.2. The VB 5 Custom Control Edition screen looks like Visual Basic.

The initial name that the VB 5 Custom Control Edition gives to the control you build is UserControl1; hence the Name property value and the name in the Project window. Most of the tools, windows, and menu objects are exactly the same for the ActiveX control and for your regular Visual Basic session.

Custom controls are tedious to create. Not only must you know Visual Basic and all its language and inner workings (as you do now), but you also need to understand the way ActiveX controls are built and you must understand the wizards available with the VB 5 Custom Control Edition that help you build the controls. Although you'll need to get some fairly heavy training before you learn to build controls with the VB 5 Custom Control Edition, consider the following points:

  • Many ActiveX controls are based on existing controls. Therefore, if you were going to create a new kind of command button, you'd start with the regular command button and build on it. You would place a command button in the center of the VB 5 Custom Control Edition's Form window and add functionality to the command button to turn it into your own control.

  • If you are building a complex control that contains several additional controls, you can place all the foundation controls on the Form window and work with them to build the complex control.

New Term: Inheritance refers to the capability of object-oriented languages (such as C++) to base new capabilities on existing language capabilities or controls.

  • Although neither Visual Basic nor the VB 5 Custom Control Edition supports true inheritance, a wizard is available in the VB 5 Custom Control Edition to let you select functionality from existing controls and put that functionality into your new ActiveX control.
Once you design the control, you must design its interface. The VB 5 Custom Control Edition comes with wizard technology that helps you add properties, events, and methods to the control.
  • Your new ActiveX control will be capable of mimicing existing controls in all ways. Therefore, if you later add your new control to an application's Toolbox window, the Properties window will display that ActiveX control's properties, including support for drop-down list boxes from which fixed property values are available for selection. In addition, you will see your ActiveX control's pop-up statement syntax appear inside the Code window editor when you add methods to the control.

NOTE: This lesson cannot possibly describe how to build an ActiveX control in an hour's lesson. Actually, it would take an entire guide to do so. If you want a great reference, check out Teach Yourself ActiveX Control Programming with Visual Basic 5 in 21 Days ( Publishing). You'll get a glimpse of what's involved from this section, but the guide just mentioned makes you an ActiveX programming superstar.

OLE Processing

You can place objects into your application that aren't normally considered to be ActiveX controls. Although you should stick with true ActiveX controls when possible, you can use the Toolbox window's OLE control to drop items from several different applications onto the form window.

For example, suppose you want your user to be able to see a Microsoft Excel worksheet on your form and interact with the worksheet as if the worksheet were a regular Visual Basic control. Add the OLE control to your Form window. As soon as you do, the Insert Object dialog box appears, as shown in Figure 21.3.

Figure 21.3. Adding objects from other applications.

NOTE: As you install Windows applications on your computer, Windows keeps a list, in its Registry, of OLE candidates. Therefore, the Registry contains an entry that tells the system your Paint program's data is available as an OLE object. The list of applications you see in the Insert Object dialog box comes from the Registry's entry.

The Insert Object dialog box gives you the choice of inserting an existing Excel worksheet object (by clicking Create from File) or creating a new object from scratch (by clicking the Create from New option). You will only be able to create objects if you have those applications on your system, but as stated earlier, your Registry knows what is installed, so only those applications appear in the Insert Object dialog box.

Creating Inserted Objects

If you elect to create the new object from scratch, you can choose that option and double-click the object type (which, in this example, will be an Excel worksheet). Visual Basic not only loads a blank object into your OLE control on the Form window, but all your Visual Basic menus change to Excel's, as shown in Figure 21.4.

Figure 21.4. You can create an Excel worksheet in the middle of the Form window.

Once you create the worksheet, click the Form window outside the worksheet area and you can continue placing the other controls and completing your application. When you finish, run the application to see the worksheet embedded in the form.

NOTE: Although your users will not be able to edit the worksheet automatically, if they double-click the worksheet embedded in the form, an Excel menu will appear across the top of the form and the users can change and enter new values in the worksheet.

Inserting Existing Objects

Instead of inserting new objects that you must create at design time, you can insert existing objects such as an Excel worksheet. When you select the Insert Object's Create from File option, Visual Basic changes the Insert Object dialog box to the file browsing dialog box shown in Figure 21.5.

Figure 21.5. Selecting a worksheet to insert.

New Term: To link an object means that your application will contain a pointer to the object. If the object ever changes, your application's form will reflect those changes. The object is not stored with your application, but the link to the object is.

New Term: To embed an object means that your application gets a copy of the object. Therefore, if the original object changes, that change will not be reflected in your application until you or your user make the same change to the application's object. The object is stored with your application so if something happens to the original, there exists no link to be broken.

The Link option informs Visual Basic that you want to link the new object and not embed it. You can select to choose Link or not depending on how current the object must be with the original object's file.

TIP: Click the Icon option if you want the object to appear as an icon on your form when the user runs the application. If you don't click this option, the object (in this case an Excel worksheet) appears on your Form window as a small worksheet.

When the user runs your application, the user can double-click the worksheet (or the icon) to add Excel menus to the Form window and to change the worksheet.

ActiveX Documents

New Term: An ActiveX container is an application, such as Internet Explorer, that can display and activate ActiveX documents.

ActiveX documents are difficult objects to create from scratch. An ActiveX document must be contained within an ActiveX container application such as Internet Explorer. If you have Internet Explorer, try this: Start Internet Explorer but don't log on to the Internet as you might normally do. Open a Word document. If you've never tried this, you might be surprised at the results. Internet Explorer can display the Word document, formatted completely, and you can edit the document as if it were shown inside Word. Figure 21.6 shows such a document embedded inside Internet Explorer.

Figure 21.6. Internet Explorer is an ActiveX container program.

You have access to Word's menus inside the ActiveX container. Also, you can right-click over the text to see Word's pop-up menu; misspelled, foreign, and abbreviated words are underlined as possible misspellings; and you can highlight and format text by pressing Word's typical formatting keystrokes (such as Ctrl+B to boldface text).

New Term: When an ActiveX container activates an ActiveX document, all the document's usual controls and features become available.

A Word document is an ActiveX document. An ActiveX container, such as Internet Explorer, can display and let you work within the ActiveX document. ActiveX documents are going to become more important as the Internet becomes more important. The more you work within a Web browser, the more likely it will be that you'll want to view data from another source, such as a Word document. When you're working with an ActiveX document, you don't have to start Word to read the document.

Visual Basic's Professional and Enterprise Editions include a wizard that converts your forms to ActiveX documents. Although the wizard cannot convert complete applications to ActiveX documents, you can convert forms with all their features.

WARNING: Surprisingly, if your form contains OLE controls, even ActiveX-based OLE controls, those controls do not convert to the ActiveX document.

To run the wizard, called the VB ActiveX Document Migration Wizard, you must add the wizard to your Add-Ins menu by following these steps:

1. Select Add-Ins | Add-In Manager to open Figure 21.7's Add-In Manager dialog box.

Figure 21.7. Adding the wizard to the Add-In Manager dialog box.

2. Click the entry labeled VB ActiveX Document Migration Wizard and close the dialog box. The wizard now appears on your Add-Ins menu option when you display the menu.

Open the application that contains the form you want to convert to an ActiveX document.

Select Add-Ins | ActiveX Document Migration Wizard to start the wizard.

After you click Next at the introductory dialog box, select the form you want to convert to an ActiveX document.

Generally, you'll select all the defaults, so click Finish to complete the migration.

Close the ending dialog boxes. Run the application to create the migration ActiveX document file. When you exit the application, Visual Basic displays a dialog box in which you can enter a name for the ActiveX document. (The default extension that you should retain is .VBD.) The default directory is VB's directory.

Do you remember the animated form with the happy face moving up the form from Hour 18, "The Graphic Image Controls"? If so, you'll enjoy seeing it again, only this time as the ActiveX document in Figure 21.8.

Figure 21.8. You can convert any form to an ActiveX document!

TIP: You might use Microsoft Office, which is the most popular desktop suite in use today; the Office Binder application is little more than an ActiveX container. Therefore, Office users will be able to see your ActiveX documents and work with the controls contained in those documents even if those users don't use the Internet.


You've now been introduced to a whirlwind tour of ActiveX. This hour summarizes ActiveX and how ActiveX fits in with Visual Basic programming. ActiveX controls are becoming more important as Internet-based usage grows because of the strong interaction ActiveX controls have with ActiveX-enabled Web browsers.

The next hour covers another fairly advanced issue: Visual Basic objects. By learning how to work with objects through code, you will be able to increase the work your applications do.


Q I don't write programs for the Internet, so why should I worry about ActiveX controls?

As you have learned in this lesson, not all ActiveX controls are designed for the Internet. Every control you add to your Visual Basic 5 Toolbox window is an ActiveX control. You really don't have to worry much that the control is an ActiveX control, and you don't have to worry about the system technology behind ActiveX controls to use these controls. The nice thing about ActiveX controls is that they act just like other controls and have properties, events, and methods you're used to programming.

Q Again, I don't write for the Internet, so why should I worry about ActiveX documents?

ActiveX documents are becoming more and more important. Some extremely reliable sources predict that future operating systems will be little more than an Internet and ActiveX document browser. If so, forms that you create will need to be readable for that super browser, and the browser will primarily consist of an ActiveX container application. Therefore, if you want to write applications for future operating environments, you'll want to be able to convert the forms in those applications to ActiveX documents.


The quiz questions and exercises are provided for your further understanding. See Appendix C, "Answers," for answers.


1. Which came first: OCX controls, ActiveX controls, or VB custom controls?

How do you add ActiveX controls to your Toolbox window?

Where can you get additional ActiveX controls?

True or false: Programmers in other languages, such as Visual C++, can use ActiveX controls created by the VB 5 Custom Control Edition.

If you design an ActiveX control that works and looks somewhat like an existing control, what can you do to speed the development of the new control?

What is the difference between an inserted object and an embedded object?

How does the user of an application with an embedded OLE object activate that object for editing?

What is the difference between an ActiveX document and an ActiveX container?

What is an example of an ActiveX container that many Visual Basic programmers use already?

What must you do to convert a form to an ActiveX document?


1. Create a new project and add two OLE controls to the form. Place a linked Word document in one and place an embedded Word document in another. Run the application and double-click on each object and manage the objects from within the application to see the effects. Start Word and modify the object, and then rerun your application to see the change reflected in one of the objects. (If you don't use Word, you can use WordPad or another word processor as long as that word processor appears inside the Inset Object dialog box.)

In this lesson's final section you saw Hour 18's animation form converted to an ActiveX document. Run the VB ActiveX Document Migration Wizard to do the same and display the created ActiveX document in Internet Explorer (or in Netscape Navigator 3.0 or later).