Developer.com Click here to support our advertisers
Click here to support our advertisers
SOFTWARE
FOR SALE
BOOKS
FOR SALE
SEARCH CENTRAL
* JOB BANK
* CLASSIFIED ADS
* DIRECTORIES
* REFERENCE
Online Library Reports
* TRAINING CENTER
* JOURNAL
* NEWS CENTRAL
* DOWNLOADS
* DISCUSSIONS
* CALENDAR
* ABOUT US
----- Journal:

Get the weekly email highlights from the most popular online Journal for developers!
Current issue -----
developer.com
developerdirect.com
htmlgoodies.com
javagoodies.com
jars.com
intranetjournal.com
javascripts.com

REFERENCE

All Categories : ActiveX

Chapter 1

Microsoft's Web Technologies:
The Debut of ActiveX


CONTENTS

What is ActiveX? That's a good question that even Microsoft itself hasn't been able to answer easily. In one sentence: ActiveX is anything that Microsoft can give to the developer community that will bring about the integration of the computer desktop environment with the environment that makes up the Internet and its myriad resources and potential, all the while leveraging existing developer investments in Windows technology. That is a big sentence, but it's not so hard to digest.

ActiveX comprises a series of extensions and enhancements to two existing Microsoft technologies: the Windows 32-bit Application Programming Interface (Win32API), and the Component Object Model (COM), upon which Object Linking and Embedding (OLE) applications are built. To get these extensions into the mainstream developer community as rapidly as possible, Microsoft has made available the ActiveX Software Development Kit (SDK). The SDK can be downloaded via the Microsoft Web site (see Figure 1.1) at

Figure 1.1 : A page from Microsoft's Internet Development Web site.

http://www.microsoft.com/intdev/

The ActiveX SDK, in both the alpha and beta releases, includes a slew of programming tools, examples, and documents-more than enough for several books, in fact. This book will focus on the core of the ActiveX SDK, including the following:

  • New tools for developing and managing HTML content, including
    VBScript, Control Pad, and support for Cascading Style Sheets.
  • Enhancements to existing COM technologies that are Internet related, such as the URL Moniker, the hyperlinking APIs, the URL Open Stream API, and the ActiveX template library.
  • The Win32 Internet API, WinInet, which offers alternative methods of developing Internet-enabled applications.
  • Support for adding OLE controls, now named ActiveX controls, to Web pages.
  • A series of new Internet controls called the Internet Control Pack.
  • The Internet Server API, ISAPI, which allows for adding extensions and filters to Microsoft's Internet Information Server (IIS). (ISAPI was in the alpha release of the ActiveX SDK but has now been moved to the Win32 SDK.)

This chapter briefly covers the topics necessary to get started working with the ActiveX SDK. You'll read a brief history of how Microsoft came to develop ActiveX; descriptions of the ActiveX Software Development Kit components; instructions for installing it; and a rundown of the other software necessary or useful for programming ActiveX applications. Let's start with the short history lesson.

The Microsoft Internet Strategy Takes Shape

Microsoft did not have a discernible Internet strategy until an important press conference in December 1995, when Bill Gates announced a broad vision for his company's plans for the future. Also in that month, Microsoft's Web site offered a new software development kit (SDK), code-named "Sweeper." This finally became a blip on the public's radar screen in March 1996, at the Professional Developer's Conference (PDC) in San Francisco, where Microsoft demonstrated the power of the new tools, renamed ActiveX.

The ActiveX demos were impressive despite occasional technical difficulties. Microsoft and other industry leaders presented VBScript, an implementation of OLE Scripting; ActiveX Controls, for embedding OLE Controls into HTML documents; ActiveX Conferencing, which enables sharing data as well as applications over TCP/IP; the Internet Control Pack, allowing developers to make their applications Internet aware; and numerous other ActiveX technologies.

The conference speakers described the ActiveX Tools as evolutionary rather than revolutionary, having been grown and nurtured over the years by Microsoft and other companies. An analog of VBScript, for example, has been seen on the Web in the form of JavaScript, and Visual Basic for Applications (VBA) has been a part of Microsoft applications for years. With ActiveX, scripting is enabled through the new OLE Scripting Service, which lets developers adapt a wide range of scripting languages for use in other environments besides a Web browser. In fact, the alpha version of Microsoft's Internet Explorer browser understood both VBScript and JavaScript; subsequently, the beta version released in July 1996 included full-blown Java support.

Similarly, the ActiveX Controls (formerly known as OLE Controls) are not new technology. What is new is that thousands of software developers can adapt their existing controls to work within a Web browser, such as Internet Explorer. Indeed, a major theme of the PDC was the leveraging of the existing technology of independent software vendors (ISVs)-without their having to rebuild their products from scratch.

The ActiveX controls are seamless on the Web client side, with automatic download and verification of the underlying code built into the specification. This is a major improvement over two existing Web technologies: Netscape plug-ins and Java applets. Netscape plug-ins must be downloaded and installed before using. Java applets (small pieces of network bytecode transmitted server-to-client across TCP/IP) must be rewritten by the ISV in the Java language, which is nearly as complex as C++. With ActiveX Controls, ISVs can adapt their existing products to work on the Web. This is a significant development not just for the look of the Web, but also for software vendors, who can expect to expand their market.

ActiveX Tools and ActiveX Controls exemplify another theme of the PDC: "activating the Internet." Currently, interactivity on the World Wide Web (WWW) is provided by two disparate technologies: increasingly complex Common Gateway Interface (CGI) scripts, which stretch server resources to the maximum; and client-based solutions such as Java and specialized plug-ins. ActiveX is a more coherent, integrated environment for adding interactive content to a Web site.

Underlying the ActiveX environment is the third and most significant theme of the Conference: Microsoft's integration of the Windows desktop and the WWW browsing model into one seamless "experience." The most striking example of this integration is the rebuilding of Internet Explorer into a simple document-container application, capable not only of browsing the Web, but also of hosting data from other Windows server applications such as Word or Excel. For the user, this means not having to open a window outside the Web browser when encountering a hyperlink to another application's document. By selecting the link, the document can be viewed or edited within the browser. This document doesn't even have to be located on the user's PC or local LAN, but can be anywhere on the Internet. The user's desktop/LAN are literally extended to seamlessly include the entire Internet, available via a click of the mouse.

The Path to ActiveX

Earlier we stated that ActiveX is not revolutionary but evolutionary technology. Let's review a bit of industry history and see how Microsoft has been following a path to ActiveX for many, many years.

In the early days of microcomputing (1980-1985), various companies attempted products that would "do everything" for the end user-Symphony, Jazz, and Framework are a few examples. These huge, monolithic programs were intended to provide, in one single package, all the functions a user would ever need to be productive. These superapplications all failed to one degree or another, mainly because they always lacked at least one other application or feature the user needed. To compound the inadequacy, the user either couldn't run the applications simultaneously, or data could not be easily shared between the monolith and the other applications.

Bill Gates publicly criticized the "do-everything" concept, insisting instead that integration should be at the operating system (OS) level, not at the application level. IBM attempted this sort of integration with its Systems Application Architecture (SAA), which would have integrated the various mainframe, mini-, and microcomputers that IBM built into a seamless user and developer interface. The SAA vision failed to be accepted; many of its concepts were never translated into working code on various platforms.

Enter OLE

While Microsoft was building Windows into a robust and stable platform, the integration between desktop applications began. Object Linking and Embedding (OLE) version 1.0 was introduced in the early 1990s. OLE 1 allowed a user to place data from one application, such as an Excel spreadsheet, inside another application's data window, such as a Word document. This was the first step toward Gates's goal of OS-level integration.

OLE 1 became OLE 2, which introduced "visual editing," whereby a user could access the functionality of one Windows application within the frame of the currently active application. For example, by double-clicking on that Excel spreadsheet in the Word document, the user could edit the spreadsheet in place, without having to open a separate Excel window.

OLE 2 eventually became just OLE and was no longer merely an acronym for object linking and embedding. With today's OLE, applications can be programmed as "objects" (there are many definitions for that word), which can act as separate applications and be used by other applications as needed. OLE enables developers to create software "components," code modules usable by other applications or components. Entire applications can be constructed from these building blocks, much as one would assemble a model plane from a kit.

Microsoft has put out a significant amount of documentation on OLE, including the comprehensive Web site at

http://www.microsoft.com/oledev/

illustrated in Figure 1.2.

Figure 1.2 : Microsoft's OLE Development library begins here.

The COM Foundation

OLE is built upon the Component Object Model (COM), which is discussed more fully in Chapter 3 Rather than a programming tool in itself, COM is a specification for an extensible architecture in which services can be seamlessly added. In many respects, COM is the current manifestation of what Bill Gates talked about back in the early 1980s: integration at the OS level.

COM allows for growth even beyond desktop integration, to include the vast resources and power of the Internet. This is what ActiveX is truly all about. Of all the proposed definitions of ActiveX, perhaps the simplest and best is "a set of tools, conforming to the COM spec, that lets a developer use new or existing tools to integrate the computer desktop environment with the World Wide Web environment."

The base COM specification is fairly stable, because part of the spec allows for further extensibility. ActiveX is an emerging technology and will continue to grow.

Your Introduction to ActiveX

This book's examination of current ActiveX tools will give you a firm foundation to begin using and exploring those tools. The starting point is, of course, the ActiveX SDK. In addition to the SDK itself, you'll also want to get familiar with a few other Microsoft tools introduced in this chapter and used throughout the book. These tools include Microsoft's Internet Information Server (IIS), the ODBC connectivity tools, Visual Basic, and Visual C++ (VC++).

Don't feel constrained to use Microsoft products exclusively. It is not necessary to use IIS, for example, to deliver HTML documents with embedded VBScript or OCXs. Nor is it necessary to use Microsoft's VC++ compiler to create applications. For the purposes of instruction, however, it is much simpler for us to focus on one set of tools. That said, let's look at the ActiveX SDK.

The ActiveX SDK

A Microsoft SDK is not a retail-style, nicely packaged product filled with easy-to-use manuals. You should definitely take the time to open up the SDK in either File Manager or Explorer and look at everything that is in the kit. Although the ActiveX installation program described below will set up critical files needed for developing applications in Visual C++, there are a number of directories that you should pay attention to after installing the SDK.

A Note of Caution

You should expect that the contents of an SDK can change significantly between releases. When we started to write this book, we had only the alpha version of the SDK. The first beta version included a number of new documents, and several documents and example applications from the alpha version had disappeared. The ISAPI material, for instance, was moved to the Win32 SDK. Meanwhile, several example programs from the alpha version vanished-SurfBear, for instance. The material in this book is based on the first beta version, not the alpha.

You'll want to carefully check the contents after installing a new version of the SDK, and we highly recommend keeping prior versions around for a while at least.

Installation

The ActiveX SDK is included on this book's CD-ROM. The SDK can also be retrieved from Microsoft's Web site via the link

http://www.microsoft.com/intdev/sdk/

Follow these steps to install the kit:

  1. Move the file to a temporary directory and unzip it, using the -d parameter to expand files into the appropriate subdirectories.

NOTE
You'll need to use a program such as WinZip, which understands long filenames. An eval copy of WinZip, recommended by Microsoft, can be downloaded from http://www.winzip.com/.

  1. Run SETUP.EXE, located in the temporary directory created in step 1.
  2. Select the Custom Setup option, and choose the directory in which you want to install the SDK. The default installation directory is C:\INetSDK.

SETUP.EXE will copy files appropriate to your platform (Win95 or NT). It adds a program group to the Start Bar containing links to a readme file with the latest updates to the SDK, and a couple of HTML files containing indexes to the \Help and \Specs subdirectories. These HTML files do not, however, list all of the documents in the SDK, so remember to look around in File Manager for additional readme or .txt files.

At this point, you can proceed to compile the sample ActiveX applications.

  1. Run the batch file called setenv.bat [directory] in the installation directory, where [directory] is your installation directory. This file simply sets up a few path variables for the next step.
  2. Run the makeall.bat file located in C:\INetSDK\SAMPLES.

If any significant errors occur during compilation, consult the readme file in the \INetSDK directory. After that, each of the subdirectories have Makefiles that can be adapted as necessary.

A Quick Tour of the ActiveX SDK

In this section we will take a walk through the beta version of the SDK. This isn't meant to be a complete listing of every program in the SDK but will highlight a number of interesting example programs that will give you a taste of the possibilities opened up through the ActiveX extensions.

Our quick tour is organized around the six directories in the \INetSDK installation directory.

\BIN

The \BIN directory contains a number of security-related utility programs for adding verification keys to code files for "safe downloading." In Chapter 8we'll talk about these files and a few other security issues.

Also in the \BIN directory are files for creating distribution versions of ActiveX programs; several registry edit (.reg) files to change the settings for Internet Explorer; a couple of utilities such as OLEView and the ODS Tool; and a couple of binaries for setting up a User Location Service.

\HELP

The \HELP directory contains a somewhat diverse collection of HTML documents. The contents page for this directory is show in Figure 1.3. The files here are important and deserve your attention, but they don't really do justice to the core of ActiveX.

Figure 1.3 : Contents of the \HELP directory in the beta version of the SDK.

\SPECS

The \SPECS directory contains over 5MB of Word documents and HTML files. This is the place to really get into what's going on with ActiveX. The starting point is Overview.Htm, which contains links to the other .htm and .doc files in the directory. However, beware of relying on these files as the "final word"-here and there, the documentation is inaccurate or out of sync with the actual implementation.

\INCLUDE

The \INCLUDE directory contains header and other files needed for compile-time support. This directory holds the files that will become your best friends when you're developing ActiveX applications. The header, typelib, and object definition files in this directory represent the definitive documentation for the SDK in terms of creating programs in VC++. For us, the online documentation occasionally specified something that simply refused to work properly (such as a parameter type). By consulting the appropriate header file, we were able to resolve the difficulty.

\LIB

The \LIB directory contains library files need for compile-time support. The setenv.bat file puts this directory before other directories in terms of search preference.

\SAMPLES

The abundant \SAMPLES directory contains source code for an assortment of Microsoft sample applications.

  • The BaseCtl directory includes documentation and source code for building non-MFC OLE controls. Building an OLE control without MFC reduces the size and improves the performance of the control. We generally used MFC for development in this book, but Chapter 5 takes a look at the BaseCtl framework and builds a simple control with it.
  • The Framer application is an example of a Document Object host-that is, a container application that can open and view DocObjects (such as Word or Excel files) within its own frame. Chapter 3 explores this application, how it works, and what needs to be done to enhance it. Figure 1.4 shows a Word document opened in Framer.

    Figure 1.4 : The Framer application hosting a Word document.

  • The MSConf directory contains an implementation of the Conferencing API, which we will look at in Chapter 9 MS Conferencing allows users to communicate across a network and to share applications as they do so.
  • The Sproids game in the OLEScript directory demonstrates how to build an application that understands a script language such as VBScript. VBScript itself is introduced in Chapter 2 but we decided that developing our own script-hosting application was well beyond the scope of this introductory book. Sproids also provides relief from the tension of ActiveX, as shown in Figure 1.5.

    Figure 1.5 : Sproids, as played by a beginner.

  • The Progress example in Figure 1.6 illustrates a bare-bones implementation of the URL Moniker, allowing the user to download raw the HTML for a Web page and display part of it in a dialog box. In Chapter 3 we will expand on this example, showing how to feed the HTML into an edit control.

    Figure 1.6 : The Progress dialog application.

  • The Range example is a somewhat obscure console application, combining elements of the URL moniker and the WinInet API to download a "range" of raw HTML from a specified URL.
  • The URLPad program allows the user to download a file from the network into an editor, using the URL Openstream API discussed in Chapter 3 Figure 1.7 shows a sample URLPad File Open dialog.

    Figure 1.7 : URLPad displaying the HTML for the Microsoft home page.

  • Chapter 2 introduces VBScript. \SAMPLES includes the source code for the VBScript demos on the Microsoft Web site. Finally, Hangman is available on the Net, as shown in Figure 1.8.

    Figure 1.8 : Another Hangman winner.

  • The WebPost directory contains a client application and a provider application using the WebPost APIs (Chapter 9. These APIs allow a user to retrieve Web pages from a provider and then post the pages back to the provider's server.
  • Last but equally important is the WinInet directory, which in the beta release of the SDK contains the AsyncFTP application as seen in Figure 1.9. In Chapter 4we will cover WinInet and develop a couple of sample applications.

    Figure 1.9 : The AsyncFTP application.

NOTE
You'll also want to take a look at the SurfBear application on the Microsoft Web site at http://www.microsoft.com/intdev/prog-gen/inet-f.htm, which uses WinInet to retrieve raw HTML across the network.

  • In addition to the above listed sample applications in the June beta release of the ActiveX SDK, the alpha version contained the Internet Server API (ISAPI) documentation and sample code. This has now been moved to the Win32 SDK. We will cover ISAPI anyway, in Chapter 7 it is an important tool in the Microsoft Internet strategy. It enhances or replaces the sometimes tedious work formerly performed by Common Gateway Interface (CGI) applications.

Other Tools

Now that we've looked at the ActiveX SDK itself, let's turn our attention to a few of the tools you might want to have on hand to develop ActiveX applications.

Not all of these programs are required to develop ActiveX applications. For example, the Internet Explorer installation program sets up the appropriate files necessary for it to understand VBScript and JavaScript. Web pages that contain such scripts do not need to be served by Microsoft's Internet Information Server-any Web server will do. Similarly, OLE controls can be developed in languages other than Microsoft's Visual C++. In general, however, you will find it easier to work with the Microsoft tools described below.

Internet Explorer 3.0

The first version of Internet Explorer, Microsoft's Web browsing tool, was an add-in to Word that allowed the user to (slowly!) browse the Web. Version 2, released as a standard, separate application, was a huge improvement. The final level-2 release, available on a variety of platforms, is compatible with the HTML 2 and 3 specs.

Now Internet Explorer 3.0, as shown in Figure 1.10, brings the browser closer to industry standards and incorporates features not readily available in other browsers. Beginning with the alpha version 3, Explorer has been rebuilt into a Windows document-container hosting application that also understands HTML. This key feature is what sets Internet Explorer apart from other browsers. The latest Explorer version also incorporates a few Microsoft-specific enhancements.

Figure 1.10: The Internet Explorer 3.0 home page.


NOTE
Explorer 3.0 generally conforms to the HTML 3.2 specification announced at the Fifth World Wide Web Conference, May 1996, in Paris. You can get full details about this conference at.

http://www5conf.inria.fr/

Following are a few Explorer enhancements that are new to the browser playing field:

  • Support for the proposed <OBJECT> tag, which lets the HTML designer embed objects such as OLE Controls in an HTML document.
  • Support for the proposed <SCRIPT> tag, for in-line scripts within HTML documents. Explorer 3.0 understands VBScript, a subset of Visual Basic, and JavaScript (see Chapter 2.)
  • Document object hosting: Because Explorer 3.0 is a document container application, it can now host Word, Excel, and other types of documents, provided the client user has the appropriate server application (or viewer) on the local machine or the LAN. (This feature has not been fully implemented as we go to press but should be available shortly.)
  • Enhanced graphics support, including in-line rendering in two additional formats (.bmp and .png). There is support for setting the background of table cells and choosing frame attributes, and for palette control over objects placed within the Explorer frame.

Internet Explorer 3.0 is still in beta form, but its popularity is growing as it incorporates features found in other browsers and adds the enhancements mentioned above. The code presented in this book assumes the reader has IE 3.0 beta or better. The alpha version of IE was included in the ActiveX SDK but is now a separate downloadable file, available at

http://www.microsoft.com/ie/

Internet Information Server (IIS)

The Web server originally released by Microsoft was a repackaged version of the EMWACS server for NT. Today, the Internet Information Server (IIS) is all original Microsoft code, according to one Microsoft source. IIS offers the features expected of today's Web servers, including built-in security, support for virtual domains, directory aliasing, and the ability to manage other servers on a local network.

By the way, EMWACS, one of the original servers for NT, is still available at

http://emwac.ed.ac.uk/html/internet_toolchest/https/

Setting Up IIS

By default, setup.exe will offer to install IIS in the following directories: \wwwroot, \ftproot, \gopherroot, and \scripts. As usual, it's a good idea to do a little planning for your installation. Consider the following:

  • Gopher will get added to the Startup Services list, so deselect Gopher unless you plan to actually use it.
  • If FTP services are configured to allow for anonymous uploading, put FTP on a separate partition to restrict the amount of data that can be uploaded at any one time.
  • For development purposes, consider turning off automatic startup of FTP services. (See information in Chapter 4about debugging ISAPI applications.)

Using the IIS Internet Service Manager

The IIS Internet Service Manager (Figure 1.11) gives you control of most aspects of IIS administration.

Figure 1.11: The IIS Internet Service Manager's Report view.

Selecting a service to administer brings up the Service page of settings (Figure 1.12), where you can control various properties of the service. The Anonymous Logon and Password Authentication properties in this page are discussed in the upcoming section on NT Security. You can use the Comment field when users are working in a multiserver environment and you want to add some identifying information about your server, such as its function or purpose.

Figure 1.12: Service properties for a WWW server.

In the Directories page (Figure 1.13), you configure directory aliases for the server. In this example screen, three directories have been added: two that allow access to directories where the ActiveX toolkit is installed, and one for a \projects subdirectory where Visual C++ is installed. Also, note that the options for Enable Default Document and Directory Browsing Allowed are global options for the server, regardless of whether a directory on the screen is selected.

Figure 1.13: The Directories properties for a WWW server.

Figure 1.14 shows the specific Directory Properties dialog for setting a few other options specific to a particular directory. With this screen it is possible to add virtual host names when a multihomed host is being configured. In this case, there are additional network considerations, such as a properly configured domain name and IP number.

Figure 1.14: Directory Properties dialog for a virtual directory.

For HTML directories, set the Access option to Read. For script/program directories, allow only Execute access, particularly if directory browsing is allowed on the Directories property page.

The Logging page in Figure 1.15 shows the options for logging access to the WWW server. Here you specify logging server access to either a file or an SQL/ODBC database. If you aren't sure that it is wise to store the log data in an ODBC table, it's a good idea to choose Log to File. Later, the Bulk Copy program (bcp.exe) can be used to add the log file data to an SQL table, because the data is stored in a comma-delimited ASCII file. However, keeping log files is recommended.

Figure 1.15: The Logging properties for a service.

Limiting Access to the Server

The Advanced page of service properties (Figure 1.16) allows the developer to limit access to the server by IP number and/or the amount of network traffic. Note that (like the directory options) these Advanced properties are global settings that will affect all Internet services and directories. Use these restrictions with care, particularly if the server is a multihomed host.

Figure 1.16: The Advanced properties for a service.

NT Security and IIS

NT security has been described as "strange" by at least one administrator we know. It is substantially different from the simple UNIX user and group model. Handling security through the Windows GUI may appear simple on the surface, but we advise you to study how security works under NT.

NOTE
Windows NT 3.5 Guidelines for Security, Audit, and Control, published by Microsoft Press, is the definitive text on NT security.

The IIS installation procedure by default adds to the host machine a user account with the name IUSR_[domain] (the domain name for the NT system on which IIS is running). A password is generated for the account, and the user ID and password are added to all of the service's property sheets, with Anonymous or Guest access. This user ID is what will show up in the access log.

Microsoft recommends that the password be changed in the User Properties dialog (see the User Manager for Domains option in the Administrative Tools menu).

WARNING
It is essential that the IUSR_ password not be blank! The IUSR_ account must have the right to "log on locally," as shown in the User Rights Policy dialog in Figure 1.10. If the password is left blank, anyone can log on to the overly trusting machine as the IUSR_ user.

Protecting Directories

You can restrict directory access to only valid NT users having the privileges to access those directories. This works similarly to the NCSA scheme of protecting directories. Attempts to access the directory will be met with the familiar Userid/Password box. A user without both a valid account and the proper Read or Execute rights to the directory will receive an authorization failure.

Here are the steps we took to protect specific directories on our test NT workstation:

  1. We created a group named WWWguest and added the IUSR_ account to it.
  2. We created a group named WWWuser to be the group with access to a subdirectory. This group can include other groups (for example, all users within the local domain).
  3. We gave everyone Read access to the root.
  4. For the subdirectory we wanted to protect, we gave access only to the WWWuser group.

This notion can be extended to the file level. However, bear in mind that the further down into the directory tree you set privileges, the more administrative headaches you'll have in the future.

Also, it's important to note that some unspecified limitations exist on the number of users an NT system can support. Trade magazines report rumors that the machinery creaks a bit when the user load exceeds 1,000 or so.

Given the potential pitfalls of relying on NT for security, we recommend developing a custom authentication scheme for restricting access to Web pages-one that bypasses the built-in NT security system-and passing the Web user requests through an ISAPI filter.

Internet Database Connector

The Internet Database Connector (IDC) is built in with IIS. Though not a part of the ActiveX SDK, it's worth mentioning as another "free" tool from Microsoft. (Well, almost free: If a Web site is using Microsoft SQL Server to publish public Web pages, an unlimited license must be purchased. The IDC itself is free, and if another data source such as Access or FoxPro is used, then there is no license fee for publishing data on the Web.)

The IDC allows the developer to query ODBC-compliant databases such as MS-SQL, Access, and FoxPro, and then pass the results back to the client in HTML format. This exchange is accomplished by first creating a Post method form, which calls an .idc file containing an SQL query. This file also contains the name of an output format (.htx) file that defines how the output will be displayed to the client.

Database interface tools such as IDC are almost as old as the Web itself, and Microsoft's version is not the first to hook into ODBC-compliant data. Among similar tools worth investigating are WebDBC from Nomad Development, available for evaluation at

http://www.ndev.com/

and Cold Fusion from Allaire, available at

http://www.allaire.com/

Both offer significantly more functionality than IDC at this time. Microsoft has indicated that IDC functionality will be enhanced in future releases.

Visual Basic 4.0

The programming language BASIC, yesterday's stepchild, has seen a dramatic revival in recent years. In its new clothing as Visual Basic, it has been extended to be a GUI window painter and a code builder, and even sports a compiler to generate distributable *.exe executable modules. Who would have dreamed in the early 1980s that Microsoft would extend BASIC to support object-oriented notions of classes, methods, and inheritance? Yet that is precisely what has happened.

Today's enhanced version of Visual Basic is used by thousands of developers. In addition to the stand-alone version, there is an application-level version, Visual Basic for Applications (VBA), which facilitates automation of programs such as Word and Excel.

As you'll see in Chapter 3 C++ lends itself naturally to development of COM and OLE programs. This does not, however, invalidate the effectiveness of other languages, including Visual Basic, for such development. In the June 1996 issue of Microsoft Systems Journal, Joshua Trupin describes in three paragraphs how to write a "…simple, yet highly functional Web browser and ActiveX document shell…" using Visual Basic. No wonder VB is so popular!

Although this book focuses on using Visual C++ to develop ActiveX programs, Chapter 6also gives examples in Visual Basic. For "quick and dirty" applications, or in situations where performance is not necessarily an issue, there is often no reason not to use Visual Basic.

Using VB-Specific OLE Controls as Explorer Objects

Visual Basic comes with a number of OLE controls that can be embedded into Web pages with the <OBJECT> tag. In Chapter 2you'll see an example of how to use the graph32.ocx to display data retrieved from an SQL query.

The VB help pages on a particular control will provide all of the proper <PARAM> field names and the type of data expected. The Class ID of the control can be found in the system registry.

Visual C++

Microsoft's Visual C++ is used to develop examples in this book. Beginning with the 4.1 Subscription Update, Microsoft has added ActiveX-related MFCs, project creation wizards, and sample applications to Visual C++ and the Developer Studio front-end. This book is not a tutorial on VC++ itself, but we will walk you through the steps necessary to create the sample applications in this book.

Creating a Project Workspace for the SDK Samples

If you are studying the source code for the sample programs in the ActiveX SDK, it's a good idea to create project workspaces for the various samples. Here are the steps to create a workspace for the Progress example discussed in Chapter 3.

  1. Select File | New | Project Workspace in the Developer Studio toolbar.
  2. Type progress for the Name field and select Application for the Type. Use the Browse button to set the correct directory-for example,
    C:\INetSDK\Samples\Progress.
  3. Select Insert | Files Into Project to add the .Cpp, .Rc and .h files into the project.
  4. Select Build | Settings | Link and add any .lib files necessary for the project. For the Progress program, the Makefile contains the following line, so we added urlmon.lib and uuid3.lib to the Object/library modules list:
    progress.exe: progress.obj progress.res
      $(link) $(lflags) $(ldebug) -out:progress.exe progress.obj progress.res 
    $(olelibs) urlmon.lib
    uuid3.lib

  1. Save the project workspace and build the program.

Figure 1.17 shows a ClassView screen for the Progress application workspace.

Figure 1.17: The ClassView screen for the Progress application.

ActiveX Additions to Visual C++ in the 4.1 Subscription Update

The 4.1 Subscription Update to Visual C++ offers a number of new MFC classes, sample applications, and third-party OLE controls. Five new ActiveX-related classes have been added to support ISAPI: CHttpServer; CHttpFilter; CHttpServerContext; CHttpFilterContext; and ChtmlStream. These classes are discussed in Chapter 4 along with a new Setup Wizard for creating ISAPI applications.

ActiveX Template Library

To aid developers in creating Component Object Model (COM) objects, Microsoft has created the ActiveX Template Library. Installing this kit adds an AppWizard to the New Project Workspace menu. This allows the user to generate a skeleton COM applications. Chapter 3discusses COM, the AppWizard, and the template library.

The ActiveX Template Library is available on the Microsoft Visual C++ Web page at

http://www.microsoft.com/visualc/

Win32 SDK

The Win32 Software Development Kit, available via the Microsoft Developer Network, is a necessary item for developing some ActiveX applications. This includes applications using APIs such as WinInet, WebPost, and Hyperlinking. Aside from this, the Win32 SDK is an overall "must have" for any serious developer. In addition to the Win32 and other SDKs, it also includes a number of utility programs, reference material, and source code for developing applications in the Windows environment.

You can get information on subscribing to the Developer Network at

http://www.microsoft.com/msdn/

In addition, you should regularly take a look at Microsoft's Win32 Web page, shown in Figure 1.18. This site regularly contains updates and sample source code.

Figure 1.18: The Win32 Web site contains regularly updated articles and source code.

Since the December 1995 Bill Gates press conference, Microsoft has posted a steady stream of free and beta tools, utilities, and even graphic and sounds files to the Microsoft Web site. These include FrontPage, dbWeb, HTML viewers, and conversion programs for Word, Excel, PowerPoint, and other Microsoft programs. Descriptions of these tools are beyond the scope of this book, and we encourage you to investigate Microsoft's Web pages to learn more about them. For example:

  • You may well have need of an HTML authoring program. HTML authoring tools at the Microsoft Web site include a beta version of Front Page, which can be downloaded from
    http://www.microsoft.com/frontpage/

In addition, Front Page has Web server extensions that let you administer locally connected Web servers. These extensions are available for a variety of OS platforms, including NT and a variety of UNIX platforms.

  • A beta version of an ODBC tool, dbWeb, provides a GUI interface for quickly creating HTML forms for querying ODBC-compliant databases. With dbWeb, creating complex query forms is easier than with IDC; however, the GUI interface makes it more difficult to customize the final output. The home page for dbWeb is at
    http://www.microsoft.com/intdev/dbweb/
  • HTML viewers are available for the major Microsoft applications family-including Word, Excel, and PowerPoint [FT-VIEWERS]-allowing you to publish these document types directly on the Web.
  • If conversion to HTML is necessary, various Assistants [FT-ASSISTANTS] are available that convert Microsoft document formats to HTML.


HomeAbout UsSearchSubscribeAdvertising InfoContact UsFAQs
Use of this site is subject to certain Terms & Conditions.
Copyright (c) 1996-1998 EarthWeb, Inc.. All rights reserved. Reproduction in whole or in part in any form or medium without express written permission of EarthWeb is prohibited.
Please read the Acceptable Usage Statement.
Contact reference@developer.com with questions or comments.
Copyright 1998 Macmillan Computer Publishing. All rights reserved.

Click here for more info

Click here for more info