Visual-C PDF

Chapter 1: Introduction to Visual C++
Certification Objectives. 1
Introduction to Visual Studio. 4
Introduction to Visual C++. 6
Installation Requirements. 13
Installing Visual C++ 6.0 Using Visual Studio. 18
Installing the MSDN Library and InstallShield. 26
Server Tools. 30
Service Packs. 34
From the Classroom.. 37
Certification Summary. 38
Two-Minute Drill 39
Certification Objectives
Using Microsoft Visual C++ and Visual Studio
Installing Visual C++ Development Tools
Welcome to your first steps toward achieving success with the Visual C++ 6.0 Desktop exam. Whether youre a long-time C++ programmer
or new to Visual C++, youre bound to be impressed by whats included in Visual C++ 6.0 and the sheer power and performance of this
development platform. We will build your knowledge of Visual C++ 6.0 throughout this book. This chapter will start you off with an
overview of the development tools included in the various editions of Visual C++ 6.0 and Visual Studio.
As well see, Visual C++ 6.0 can be purchased by itself, or as part of the Visual Studio suite of products. Although Visual C++ 6.0 is available
in each package, the products and tools available in each are quite different. To give you even more decisions on acquiring Visual C++ 6.0,
you also have a choice of three editions: Standard, Professional, and Enterprise.
From here, well discuss how to install Visual C++ 6.0, and the minimal system requirements for different editions. This will ensure that
Visual C++ 6.0 is properly installed and ready for use. Finally, well delve into how to acquire and install service packs which resolve known
issues with your installation of Visual C++ 6.0 and other products in the Visual Studio suite.
Using Microsoft Visual C++ and Visual Studio
The first steps to using Visual C++ 6.0 are acquiring it, knowing what tools are available, and knowing what those tools are for. The first of
these steps may seem simple at face value, until you realize that Visual C++ 6.0 is available for purchase as its own package or as part of the
Visual Studio suite of products. Beyond this, Visual C++ 6.0 is also available in three different editions:
StandardThe Standard edition includes the basic products and tools for creating applications. This edition also includes tutorials and
samples, and is often the best choice for programmers who are just learning how to program with Visual C++.
ProfessionalThe Professional edition includes products and tools for creating applications, and is geared toward developers of desktop
applications.
EnterpriseThe Enterprise edition includes products and tools for creating applications, but has additional features geared toward
enterprise development.
Although Visual C++ 6.0 is available in each of these editions, Visual Studio is only available in the Professional and Enterprise editions.
Which package and edition of Visual C++ 6.0 or Visual Studio you use largely depends on individual needs and resources.
Exam Watch: Knowing the individual components of Visual Studio or Visual C++ is not a direct objective of the exam. However, knowing
this information can be useful in understanding whats being asked in a question. The Visual Studio and Visual C++ introduction sections of
this chapter serve to introduce you to what will be discussed for exam objectives in future chapters, and to aid you in understanding the
software as a whole.
Although its cheaper to purchase Visual C++ 6.0 on its own, Visual Studio comes with significantly more development tools. Although well
discuss each of these tools later, purchasing Visual Studio costs less than if you purchased each development tool separately. In other words,
you get more for your dollar, if more is what youre actually looking for.
This also can be said of the individual editions of Visual C++ 6.0 and Visual Studio. Each edition includes a variety of features, with Standard
having the smallest number and Enterprise having the most. As mentioned, Standard is particularly useful if youre just learning Visual C++
6.0, or using it as a secondary development platform. The Professional edition contains more tools, and is particularly useful for developers of
desktop and Internet applications. Finally, the high end of the editions is the Enterprise edition, which is often acquired for enterprise
development of network applications. This edition contains the most tools, and is subsequently more expensive.
On the Job: Many new developers tend make the mistake of getting more than they really need when purchasing these packages. Most
developers purchase the Professional edition for desktop, and the Enterprise edition for distributed applications. However, dont fall into the
trap of buying what you dont use. If youre only going to program with Visual C++ 6.0, then theres probably no need in buying it as part of
Visual Studio (which includes other development products).
As for the individual features of each edition and package, well discuss those in each of the sections that immediately follow. Both Visual
Cha 01:
Studio and Visual C++ 6.0 include a number of different tools that help reduce the time spent on developing applications. In addition, there
are tools that can aid in analyzing and improving the performance of your applications, as well as those that make distributing your solution
easier.
Introduction to Visual Studio
Visual Studio is a suite of products used for developing and managing applications, components, and data access. It provides you with a wider
scope of options than Visual C++ alone, because it contains more than just Visual C++ 6.0. Regardless of whether you use the Professional or
Enterprise edition of Visual Studio, you receive the following:
Visual Basic 6.0Development system based on the BASIC programming language
Visual C++ 6.0Development system based on the C++ programming language
Visual J++ 6.0Development system based on the Java programming language
Visual FoxPro 6.0Development system used for creating databases and database applications
Visual InterDev 6.0Development system used for creating Web applications
Although each of these are available for purchase separately, you can get them in one package with Visual Studio. If you purchase the
Professional edition of Visual Studio (VS), then each of the development systems included are Professional edition as well. Similarly, the
Enterprise edition also includes the Enterprise editions of these systems. Therefore, if you have VS Professional edition, then you get the
Professional edition of Visual C++ 6.0. If you have the Enterprise edition of VS, then you would be using the Enterprise edition of Visual
C++ 6.0.
In addition to these development systems, you also receive the Microsoft Developer Network (MSDN) Library, Single Edition. This is an
information resource that can help you when you need answers fast. It includes a knowledge base of information, sample code, product
documentation, software developers kit (SDK) documentation, technical documents, and examples.
The Windows NT Option Pack is also included with both the Professional and Enterprise editions of VS. If youre installing the Windows NT
Option Pack on Windows NT systems (that is, Windows NT Server or Windows NT Workstation), the option pack includes Component
Services 2.0 and Internet Information Services 4.0. On Windows 9x systems, the options in the Windows NT Option Pack are more limited.
Installing the option pack on Windows 95 or Windows 98 will install the Personal Web Server.
The Enterprise edition of Visual Studio also includes Visual SourceSafe. Visual SourceSafe (VSS) is used for version control of source code.
As well see in Chapter 2, this allows you to store your source code to a database, enabling you to restore and use previous versions of your
source code. This is useful for organizing the source code of multiple developers as well as that of the individual developer. If an improper or
incorrect change is made to source code, or you simply want to revert to the code you used earlier, you can restore that code from the VSS
database that it was saved to.
The Enterprise edition also includes the Microsoft BackOffice Server 4.5, Developer Edition. This is made up of several pieces of server
software, including, Microsoft SQL Server, Microsoft SNA Server, Microsoft Exchange Server, Microsoft Site Server, and Microsoft System
Management Server. However, if youre thinking of using this version of BackOffice Server for anything other than development, you may
want to think twice. The Developer Edition of BackOffice Server is only licensed to support ten concurrent connections. This means only ten
people can use this software at any given time.
As Table 1-1 shows, Visual Studio also includes a number of additional tools for application design, performance analysis, component
management, and designing SQL Server and Oracle databases. Most of these are only available with the Enterprise edition, but some are also
included in the Professional edition. Application Performance Explorer is a tool used for testing SQL Server queries and data connections.
Visual Modeler is used for the design of three-tier distributed applications. Visual Component Manager (which is also available with the
Professional edition) allows you to manage components by enabling you to organize, find, and insert components into development projects.
Visual Studio Analyzer is a tool used in analyzing distributed applications created with Visual Studio. Each of these tools can enhance
development of distributed and desktop applications.
Visual Studio Feature Professional
Edition
Enterprise
Edition
Visual Basic 6.0 X X
Visual C++ 6.0 X X
Visual J++ 6.0 X X
Visual FoxPro 6.0 X X
Visual InterDev 6.0 X X
Visual SourceSafe 6.0 X
Microsoft Developer Network (MSDN) Library, Single Edition X X
Windows NT Option Pack X X
Microsoft BackOffice Server 4.5, Developer Edition X
Visual Component Manager X X
Microsoft Repository X
Visual Modeler X
Application Performance Explorer X
Visual Studio Analyzer X
Table 1-1: Visual Studio 6.0 Features by Edition
Introduction to Visual C++
As part of Visual Studio, or on its own, Visual C++ 6.0 includes a number of features that can be used for creating desktop and distributed
applications. You dont get all of the development systems, such as Visual Basic or Visual J++, when acquiring Visual C++ 6.0 on its own,
but you do get the Visual C++ 6.0 development system and a considerable number of the tools included with Visual Studio. As well see, the
components included in the Visual C++ package are beneficial to the creation of robust applications.
Cha 01:
Although Visual C++ 6.0 is available in Professional and Enterprise editions through Visual Studio, it is also available as a Standard edition
when Visual C++ 6.0 is purchased on its own. The Standard edition includes the bare bones tools for developing applications, and is useful for
new programmers who wish to learn Visual C++. For this reason, previous versions of the Standard edition were called learning editions.
New to this edition are tutorials that arent available with any of the other editions. These step-by-step instructions teach you how to program
applications using Visual C++ 6.0, and are set up so that no previous knowledge of C++ is required.
Aside from these tutorials, all of the features included in the Standard version are also available in the Professional and Enterprise editions of
Visual C++ 6.0. As Table 1-2 shows, the Standard edition has many of the features included in the Professional Edition, and the Enterprise
edition has all of the features of the Professional edition plus a few more. This allows you to pick the edition that best suits your needs as a
developer.
Feature Description Standard Professional Enterprise
Tutorials New tutorials to learn Visual C++ 6.0 X
Samples Samples of source code, used for
assistance in creating applications
X X X
Microsoft Foundation
Classes (MFC) Library
The classes, global functions, global
variables, and macros used in
programming Visual C++ 6.0
applications
X X X
C\C++ Runtime
Libraries
Routines used in creating Visual C++
6.0 applications
X X X
Active Template Library
(ATL)
Used in creating server-side
components and ActiveX Controls
X X X
Internet Support Controls, APIs, and classes used for
integrating applications with the
Internet. This includes Internet
Explorer 4.0 common controls, Internet
Server Application Program Interface
(ISAPI) extensions, Dynamic
Hypertext Markup Language
(DHTML), Chttp* MFC classes
X X X
ActiveX Controls and
Document support
Ready to use, prebuilt ActiveX
Controls that can be added to your
project. In addition, there is the new
ability to create composite controls,
and you can have your applications act
as active document containers
X X X
Component and Object
Gallery
Storehouse of code that can be prebuilt
components, ActiveX controls, or user
defined components
X X X
Component Object
Model (COM) support
Support for the Component Object
Model, inclusive to compiler COM
support
X X X
Visual Database Tools Full versions of these tools are only
available in the Enterprise version.
Read-only version available in the
Professional and Standard versions
X X X
Static linkage to MFC Enables you to resolve MFC references
at link time rather than runtime
X X
Code Optimization Enables smaller, faster executables
(EXEs) and dynamic-link libraries
(DLLs)
X X
Source Code Profiler Enables you to analyze code to
determine which parts could use
performance modifications
X X
Data-bound controls RemoteData, DBGrid, DBCombo, and
DBList controls for data access
X X
Custom AppWizard Enables you to create an AppWizard to
create projects and custom starter files
X X
InstallShield Packages applications you create for
easy installation
X X
Cluster Resource Wizard Used to generate projects for
implementation of a Clustering Service
resource type
X X
Visual SourceSafe Used for version control of source code X
MFC Data binding Ability to do simple and complex data
binding to any ActiveX data control
X
Remote Automation Used for creating and running
Automation programs
X
Component Services Transaction processing server
application
X
Microsoft SQL Server
6.5, Developer Edition
Database server application X
SQL Editor and
Debugger
Integrated SQL Editor (for writing and
editing SQL statements) and debugger
(for finding bugs in SQL statements)
X
Cha 01:
Internet Information
Services
Web Server Application X
Table 1-2: Visual C++ 6.0 Features by Edition
Visual C++ 6.0 supports the Component Object Model (COM). This is an object model that enables various software
componentsapplications, controls, data objects, services, and so forthto interact as objects. These objects contain data, and provide a
method through which other components can access that data. In other words, there is an interface in which one component can interact with
another. The provider of these services or data is called the server, whereas the user is called a client. The client interacts with the server
through the servers interface, which consists of functions available for accessing necessary data.
ActiveX is built upon COM, so its no wonder that Visual C++ 6.0 supports ActiveX. Visual C++ 6.0 includes a large number of prebuilt,
ready to use ActiveX controls. New to Visual C++ 6.0 are composite controls. These are new controls that you can create by combining your
existing ActiveX and Windows controls. These are then added to the Active Template Library, and can be used in your application projects.
Each of the editions include Internet Support features, which allow you to integrate your applications with the Internet. Internet Explorer
Common Controls can be added to an application, allowing users of your application to use the Internet through your solution. Internet Server
Application Programming Interface (ISAPI) extensions are included, so you can write programs for Internet Information Services. You can
use Dynamic Hypertext Markup Language (HTML) support in Visual C++ 6.0 to manipulate data, and make interactive Web applications. In
addition to these, there are a number of CHttp* classes that can be used by your solution. These classes are as follows:
CHttpInternetConnectionManages connections to the Internet, and is the base class for the CHttp* classes that follow.
CHttpConnectionManages Internet connections to an Hypertext Transfer Protocol (HTTP) server
CFtpConnectionManages Internet connections to a File Transfer Protocol (FTP) server
CGopherConnectionManages Internet connections to a Gopher server
Each of these can be used in your application to manage connections to servers that deal with certain areas of the Internet, and to manage your
connection to the Internet itself. In addition to these classes, there are numerous objects available for use in your solution.
InstallShield is only available with the Professional and Enterprise editions. It packages applications that you create. This allows users who
wish to install your application to easily setup the application, by following step-by-step instructions. This allows your applications to benefit
from the same type of setup as products from Microsoft.
A number of server tools are included in the Enterprise edition of Visual C++ 6.0. These tools include the following:
Microsoft SQL Server 6.5, Developer Edition (with Service Pack 3)
Internet Information Services 4.0
Component Services
Microsoft SQL Server 6.5, Developer Edition allows you to test applications that you create for this database server. Because it is a developer
edition, youre limited to ten concurrent connections. Internet Information Services (IIS) is a Web server. You can use this server application
for publishing Web pages and testing any of the Web applications you create with Visual C++ 6.0. Component Services is a transaction
processing system. A transaction is a group of tasks that are executed as a single action. Together, these server applications allow you to
create, deploy, and manage applications for enterprise, Internet, and intranet servers.
Installing Visual C++ Development Tools
In many ways, there is little difference between installing Visual C++ 6.0 on Windows 95, Windows 98, Windows NT Workstation, and
Windows NT Server. There are no separate installation programs for the different platforms, and screens that appear during the installation
process are the same. The difference is that certain tools cant be installed on every platform, and certain additional measures must be taken
when installing on or from Windows NT systems.
Windows NT has higher security than Windows 9x, and Windows NT networks use permissions to dictate what applications can be used by
users, and which folders on a Windows NT systems hard disk can be accessed. On Windows NT Workstations, these permissions are set with
the User Manager program. On Windows NT Server, these permissions are set with User Manager for Domains. These programs are used to
administer accounts on Windows NT systems and networks. A major difference between these two programs is that User Manager for
Windows NT Workstation cant administer and set permissions for domain user and administrator accounts. It can, however, set permissions
for local users and groups. Which of these programs you use has a great deal to do with how your network is set up, and should generally be
discussed with your network administrator.
The reason that permissions are so important is because they control access to files and folders. This means that if your account doesnt have
access to a CD-ROM from which you want to install Visual C++ 6.0, you wont be able to access the installation files. If youre installing
from a distribution server, which has all the installation files stored on that servers hard disk, you will also need adequate permissions to
install from that servers folder. In addition, youll need proper permissions to use the files once theyve been installed. Otherwise, you wont
be able to start and use Visual C++ 6.0 after installation is complete.
Although many of the details regarding these issues go beyond the scope of this book, you should consult with your network administrator to
ensure that you have adequate access to install Visual C++ 6.0. If you do not, then you wont get far in installing and using this development
system and its tools.
In addition to having proper permissions, youll also need to ensure that the computer youre installing to meets the minimal requirements for
Visual C++ 6.0. As well see in the section that follows, this means that your computer is new and powerful enough to run Visual C++ 6.0,
that there is enough hard disk space to install, and that the Microsoft operating system currently installed is able to handle running Visual C++
6.0.
Following this, well go into the details of how to install Visual C++ 6.0 onto your computer. As well see, this can be a time consuming task
which may appear confusing at first. However, once youve gone through the process once or twice, youll find that this is relatively
straightforward, and not as complicated as it might appear.
Cha 01:
Installation Requirements
Before actually installing Visual C++ 6.0or any software for that matteryou should determine if the computer meets the minimal system
requirements. System requirements are the minimal software and hardware needed by the program to work properly. This includes such
elements of your system as the operating system used, free hard disk space, processor, RAM, and so forth. If your computer doesnt meet the
requirements of the Visual C++ 6.0 edition being installed, then the installation will fail or Visual C++ 6.0 wont function as expected.
Exam Watch: Although minimum installation requirements arent a specific objective of the exam, it is an important part of installing Visual
C++ 6.0 Development Tools, which subsequently is an objective. Many installation problems are due to the fact that the system fails to meet
the minimal requirements of the software youre attempting to install. This results in the installation failing completely, or the components
that are installed failing to function as they should. Before taking the exam, make sure you understand the minimal requirements for each
edition of Visual C++ 6.0, on both Windows 9x and Windows NT. This will help you analyze problems being discussed in exam questions,
and determine why a certain installation is failing.
As we learned earlier in this chapter, Visual C++ 6.0 comes in different editions, which include different features. The Professional edition
includes more tools than the Standard edition, and the Enterprise edition includes more than the other editions. As such, with each higher
edition used, more hard disk space needs to be used, and in most cases, a faster processor is needed. As seen in Table 1-3, different amounts of
free disk space are required in each edition to accommodate the installation of different features. Without checking the minimal requirements
before installing, you may waste time and money on an edition of Visual C++ that doesnt work on your system.
Requirement Standard Edition Professional Edition Enterprise Edition
Operating System Windows 95 or later, or
Windows NT 4.0 or
higher (with Service Pack
3 installed)
Windows 95 or later, or
Windows NT 4.0 or
3 installed)
Windows 95 or later, or
Windows NT 4.0 or
3 installed)
Processor 486/66 MHz or higher,
with Pentium 90 or higher
processor recommended
Pentium class processor,
recommended
Pentium class processor,
recommended
Random Access Memory
(RAM)
24MB with 32MB
recommended
24MB with 32MB
recommended
24MB with 32MB
recommended
Free Disk Space Typical: 225MB
Full: 305MB
Typical: 290MB
Full: 375MB
Typical: 305MB
Full: 405MB
Other Requirements CD-ROM, mouse, VGA
Monitor (SVGA
recommended), Microsoft
Internet Explorer 4.01
Service Pack 1
CD-ROM, mouse, VGA
Monitor (SVGA
Service Pack 1
CD-ROM, mouse, VGA
Monitor (SVGA
Service Pack 1
Table 1-3: System Requirements for Visual C++ 6.0 by Edition
For each edition of Visual C++, the operating system requirements are the same. You need to be running Microsoft Windows 9x or Windows
NT version 4.0 or higher. However, if youre using Windows NT, youll need to install Service Pack 3 (SP3), which is included on the Visual
C++ installation CD-ROM. Service Pack 4 and Service Pack 5 have been released, and are available on Microsofts Web site, but Visual
Studio only requires SP3 to be installed. Service packs contain upgraded files, which contain changes in code and bug fixes to known issues.
As well see later, there are also service packs available for Visual Studio. If Service Pack 3 isnt installed on your Windows NT system, then
Visual C++ may not function as expected.
The operating system requirements arent the only common requirements among the different editions. Each edition requires a minimum of
24MB of RAM, but the recommended amount of memory your computer should have is 32MB. Having this extra memory will increase
Visual C++ 6.0s performance, enabling you to do your work faster. The same can be said for the processor power of your computer.
Although Visual C++ 6.0 Standard edition only requires a 486/66 processor, its highly recommended that you use a processor that meets the
requirements of the two higher editions. This means using a Pentium class processor (Pentium 90 or higher being recommended). Although
you can get away with the bare minimum of the system requirements, often more means more. As you put more RAM, processor power, and
free disk space into your system, youll notice enhanced performance when using larger software packages like Visual C++.
Youll also need Microsoft Internet Explorer (IE) version 4.01 or later installed on your computer. This is used to display online user
assistance and any browser applications you create. If youre using IE 4.01, youll need to install the Microsoft Internet Explorer 4.01 Service
Pack 1, which is included on Visual C++ 6.0s installation CD-ROM. If you have a later version of IE, such as Internet Explorer 5, installed
on your computer, this service pack is unnecessary. The bug fixes and benefits that the service pack provides are part of the newer versions.
Some of the other requirements for Visual C++ 6.0 are common to almost any software you install in the Windows environment. Because
point-and-click navigation is the foundation of the Windows Graphical User Interface (GUI), youll need a mouse or some other pointing
device. Youll also need a Video Graphics Adapter (VGA) monitor, although Super VGA is recommended.
Finally, youll need a CD-ROM drive to install Visual C++ 6.0 from the installation CD-ROM. This may, however, not be necessary if youre
connected to a network. Rather than inserting the CD-ROM into the CD-ROM drive of your local computer, you may be able to install Visual
C++ 6.0 over the network. If you have proper permissions to access the CD-ROM drive of a network server or workstation, you can insert the
CD-ROM into the CD-ROM drive of that computer. You then access the CD-ROM drive from the workstation you wish to install to, and
Visual C++ 6.0 will be accessed over the network. If your network server doesnt have a CD-ROM drive, or that CD-ROM drive is regularly
used for other CD-ROMs, you can copy the installation files to a servers hard disk. You would then access the installation files located in the
folder ( directory) on that server, and install over the network. In using either of these approaches however, you should ensure you have
proper permissions to do so. For more information on this, consult with your network administrator.
In addition to Visual C++ 6.0 itself, the different editions include various products. As Table 1-4 shows, each edition comes with extra
software that can be used when developing Visual C++ 6.0 applications. Because each of these products take up their own space on your hard
disk, its important that you take these requirements into account when determining whether your system meets the minimal requirements for
installing a particular edition.
Product Standard Edition Professional Edition Enterprise Edition
Cha 01:
Internet Explorer Hard disk space:
Typical: 43MB
Full: 59MB
Hard disk space:
Typical: 43MB
Full: 59MB
Hard disk space:
Typical: 43MB
Full: 59MB
MSDN Hard disk space:
Typical: 57MB
Full: 493MB
Hard disk space:
Typical: 57MB
Full: 493MB
Hard disk space:
Typical: 57MB
Full: 493MB
Windows NT Option
Pack
Not Included with
this Edition
Hard disk space:
Windows 9x: 20MB
Windows NT: 200MB
Hard disk space:
Windows 9x: 20MB
Windows NT: 200MB
Microsoft SQL Server 6.5 Not Included with
this Edition
Not Included with this Edition Windows NT (wont run
on Windows 9x)
Hard disk space:
Typical: 80MB
Full: 95MB
Microsoft SNA Server 4.0 Not Included with
this Edition
Not Included with this Edition Windows NT (wont run
on Windows 9x)
Hard disk space:
Typical: 50MB
Full: 100+MB
Table 1-4: Additional Requirements for Products Included with Visual C++ 6.0
Of the different products included with editions of Visual C++ 6.0, its important to remember that not all are included with each edition, and
that some dont work on all operating systems. As seen in the preceding table, SQL Server 6.5 and SNA Server 4.0 come with the Enterprise
edition of Visual C++ 6.0. These arent included with either the Standard edition or the Professional edition. If you want to install either of
these products, you must do so on a Windows NT system. This means that your local computer must be running Windows NT 4.0 or later, or
that youll need to install these on a separate Windows NT computer. After setting the proper permissions to install, and then access, these
products on the Windows NT machine, you would then be able to use them over the network.
On the Job: Remember that just because a product or feature comes with a package, it doesnt necessarily mean that you need to install it. If
you dont need certain features or products included with an edition of Visual C++, then youre generally better off not installing them. This
will leave you free hard disk space to install software that you do need.
Installing Visual C++ 6.0 Using Visual Studio
Once youve ensured that your computer meets the minimal requirements for installing Visual C++ 6.0, youre ready to begin the installation
process. Like many of the products available from Microsoft, a wizard is used to aid you through this procedure. A wizard is a program that
takes you step-by-step through a task, with each screen showing a step in completing that task. In the case of the setup wizard on the Visual
C++ or Visual Studio installation CD-ROM, this would be the task of installing Visual C++ 6.0.
Exam Watch: If youve been running Visual C++ 6.0 on your system for awhile, you may have forgotten or become unfamiliar with installing
this software. As this is an objective of the exam, it may be wise to either uninstall Visual C++ 6.0 from your system and then reinstall, or try
installing Visual C++ 6.0 on another computer. Although reading about how to install Visual C++ 6.0 will give you the knowledge of how the
installation process works, you should reinforce this knowledge by actually going through the steps hands-on.
The setup wizard can be started in one of two ways. When you insert your installation CD-ROM into your computers CD-ROM drive, the
wizard will start automatically. If for some reason it doesnt, or if youre installing over the network, you can start the wizard by opening the
SETUP.EXE file. From the Windows Start menu, select Run and then type the path to the SETUP.EXE file. You can also use Windows
Explorer (on Windows 9x systems) or Windows NT Explorer (on Windows NT machines) to browse your local machine or network for the
folder or CD-ROM drive containing the installation files. After you double-click this file, the setup wizard will start, and a welcome screen
will appear.
The welcome screen outlines the purpose of the wizard, and how it will walk you through the process of installing Visual Studio. On this
screen, youll also notice a View Readme button, which is used to load an HTML file into your Internet browser. HTML files are documents
used on the Internet as Web pages, and may contain graphics, and hyperlinks. By clicking on the underlined text or a graphic serving as a
hyperlink, you can view other information. This document contains the latest information on your particular version of Visual Studio or
Visual C++, inclusive to installation, known issues, and so forth. If you dont wish to read this file, simply click the Next button on this screen
of the wizard to continue with the installation.
The next screen that appears is the End User License Agreement screen, which outlines the agreement between you and Microsoft on how the
product(s) youre installing can be used. You have two options on this screen: I accept the agreement and I dont accept the agreement.
Until you accept the agreement, you cant proceed with the installation. The Next button on the screen is disabled. It appears grayed out, and
nothing will happen when you click it. If you choose not to accept the agreement, then the Back button will also be disabled, allowing you to
either choose to accept or Exit the installation. Once you accept the agreement, all the buttons become enabled, and you can continue with the
installation by clicking Next.
The screen that follows is where you prove that you have a legal copy of Visual Studio. As shown in Figure 1-1, the Product Number and
User ID screen has several fields that require input. The first of these is the products ID number, which is also referred to as a CD Key. The
number you enter here can be found on the back of your installation CD-ROMs jewel case (the case the CD-ROM came in), or in your
product documentation. The number must be entered exactly, or installation will fail. The other two fields are where you enter your name and
companys name. This will be filled out for you with information that the wizard acquires from the Windows Registry. Ensure that this
information is correct, then click Next to continue.
Cha 01:
Figure 1-1: Enter the product number, your name, and your companys name to continue with the installation
What appears next depends on whether or not you have previous versions of the products installed on your computer. If you have previous
versions of products that are included with Visual Studio (inclusive to Visual C++ 5.0, Visual Basic, and so forth), the Uninstall Visual Studio
97 screen will appear. Each of the previous versions currently installed on your system will have check boxes beside them that are selected.
This indicates that you want to uninstall the previous version, and replace it with the new version of the product. However, you are able to
have previous versions of Visual C++ running on the same machine as the new version youre installing. If you wish to keep a previous
version, simply clear the check box beside that products name. Following this, click Next to continue with the installation process. If you
dont have previous versions on your system, this screen wont appear.
The next screen that youll see offers you three choices for installing Visual Studio products. These options are:
CustomAllows you to define which products and server tools youd like to install on the workstation
ProductsAllows you install preconfigured versions of Visual C++, Visual Basic, Visual FoxPro, Visual InterDev, and Visual
SourceSafe
Server ToolsAllows you to skip over installing the workstation products of the Products option, and only install server applications
The first of these options is used if you want to install both server tools and Visual Studio products. The second option installs only the
products, while the third installs just the server tools. While well discuss each of these options individually, you should realize that you can
go back and add additional products and tools later. This is something well see in the next chapter, when we install Visual SourceSafe.
Regardless of the type of installation that you choose, the next screen will ask you to specify where files used by multiple programs in Visual
Studio should be stored. A default path is entered in the field on this screen, but you can change the path to the common folder youd like to
use by typing in a new path or clicking the Browse button. When you click the Browse button, a dialog box will appear that allows you to
browse your local hard drives and the network. This enables you to specify an existing folder in which you store common files. After selecting
a folder and clicking OK on this dialog, the new path will appear in the previously mentioned field. Regardless of how or where you want to
store these files, you should be aware that Visual Studio requires a minimum of 50MB for the common folder. You should ensure that any
local hard disk or network drive that you designate as the common folder meets this requirement. You should also keep in mind that if you
choose a network drive for the common folder, and the network goes down, that Visual C++ and other products in the Visual Studio suite
wont function properly (if at all). Although each workstation will have more free disk space if you use a common folder on a server, this
shouldnt be done if network failures are common in your organization.
If you select Product as your installation type, the next screen youll see is the one shown in Figure 1-2. This lists each of the workstation
products discussed earlier in this chapter, which you can install by selecting the check box beside the products name. If a check box is
selected, the product beside it will be installed. Otherwise, it wont be installed at this time, and if you wish to install additional products later,
youll have to re-run the setup wizard. After selecting the products you wish to install, click the Next button to continue with the installation
process.
Cha 01:
Figure 1-2: Select the products that you wish to install from the Visual Studio Individual Tools Setup screen
Whether youve chosen Products or Custom as your installation type, the screens that follow from this point on are the same. The only
difference is the order in which they appear. When you select Custom as your installation type, clicking Next brings you to a Welcome screen
for installing Visual Studio. If you choose Products, then this screen appears after clicking Next from the Individual Tools Setup screen
discussed in the previous paragraph. Clicking the Continue button on this screen moves you to the next step in installing Visual C++ 6.0.
The next screen is provides you with a product ID number. This number is made up of digits added by the setup wizard to the product
registration number (CD Key) that you entered earlier in the installation process. Its important that you write this number down, and keep it
in a safe place, as it may be requested by Microsoft if you call their technical support team for assistance. After installation, you can read this
number by clicking About under the Help menu of Visual C++ and other Visual Studio products. However, even though you can access this
number from the Help menu after installation, this will be worthless if the installation doesnt complete or if you cant open Visual C++ once
its installed. Once youve documented the product ID number, click the OK button to continue.
When you first see the Custom screen after choosing the Products installation type, you may think that youve done something wrong. This
screenshown in Figure 1-3is the same one that appears when choosing the Custom installation type. However, there is a difference in
whats selected on this screen, depending on the type of installation youve chosen. When the Custom installation type is selected, most of the
options shown in the listing at the left of this screen are selected. You can then cancel the selected products and tools by clicking a check box,
and removing the check mark. If there is no check mark, the product or tool to the right of the check box wont install. If you reach this screen
by choosing the Products installation type, then only the options for the individual tools youve selected will be selected. For example, if you
select only Visual C++ 6.0 to be installed, then the Custom screen will have the options associated with that product selected. This not only
includes Visual C++ 6.0, but ActiveX and Data Access components, various tools, and Visual SourceSafe. These are preconfigured to be
selected, as they all relate to that specific product.
Cha 01:
Figure 1-3: You can install all or part of a component using the Custom installation
On the Job: It can be confusing when the Custom screen appears after selecting the Products installation type, which sets you on the track of
doing preconfigured installations of products. Remember that the Products installation type sets up the necessary options on the Custom
screen, and in this way is different from the Custom installation type.
To the right of the Options listing, youll see two buttons. The first of these is the Change Option button. When an option is selected (as
shown by the highlight in the Options listing), the Change Option button becomes enabled. This lets you know that there are options within
this particular option that you can add or remove. Clicking Change Option opens that particular option, allowing you to view these other
options. You can almost think of it as opening a folder on your hard disk to view the files within. The second button is Select All. When this is
clicked, each of the options shown in the Options listing will be selected (i.e. their check boxes will be checked) automatically. This is useful
if there are a number of items you want to install, but dont want to click each check box individually. In other words, its a bit of a time saver
for you.
Below these buttons and the Options listing, youll see the default folder where a particular option will be installed. You can change where
each product will be installed by clicking the Change Folder button, which displays a dialog box. This dialog box allows you to type the path
to another folder on your local or network drive. You can also browse your computer or network for an existing folder. If you type the path of
a folder that doesnt exist, and click OK on the dialog box, the wizard will prompt you that the folder doesnt exist and ask if it should be
created.
The Change Folder button is often used in conjunction with the information thats displayed below it on the Custom screen. There are two
lines below this button that show the space available on a particular drive, and how much is required. If the amount required exceeds the
amount available, you should specify a new folder on a drive with adequate space. If you dont do this, when you click Next, the wizard will
check to ensure enough space is available to install, and display a screen indicating which drives dont have enough free space. This screen
will allow you to return to the Custom screen, and then pick a new folder and different drive to install to.
After using the Custom screen to select or accept options to install, clicking the Continue button will cause the setup wizard to check available
space and determine any components that are already installed. For example, if it finds a previous or current version of Visual SourceSafe on
your computer, it will prompt you to decide whether the new installation of Visual SourceSafe should replace it. The setup wizard will then
begin copying files from the installation CD-ROM to your hard disk. As Visual C++ 6.0 is an enormous program, and there are a number of
other tools and components to install, this may take a few minutes to complete. It will then proceed to modify system settings and
environment variables necessary to run Visual C++ 6.0 and the other options selected earlier. When this is finished, youll be prompted to
restart your computer.
Installing the MSDN Library and InstallShield
The Microsoft Developer Network (MSDN) Library is a collection of documentation and samples for the Visual Studio suite of products. If
youre installing from Visual Studio, MSDN is included. Although this was the most recent version of MSDN when Visual Studio was
released, you can also order a subscription to MSDN through Microsofts Web site (msdn.microsoft.com). You can install MSDN by
double-clicking the SETUP.EXE file on the MSDN CD-ROM. You can also install MSDN after going through the previously mentioned steps
of installing Visual Studio.
After the computer has restarted and reloaded Windows, a screen will automatically appear and offer you the chance to install the MSDN
Cha 01:
Library. To install MSDN, ensure that the Install MSDN check box on this screen is checked, insert the MSDN CD-ROM and then click Next.
A welcome screen will appear for installing MSDN on your hard disk. Clicking Continue will show the screen we saw earlier, which
displayed the product ID. Although it appears to be identical, this is a different product ID number. For reasons discussed earlier, you should
write this number down before clicking OK to continue.
A dialog box will appear with two buttons used to show your agreement to using the MSDN library. Clicking I decline will cancel
installation of MSDN. Clicking I agree will allow you to proceed with installation of the MSDN Library.
This will bring you to the screen shown in Figure 1-4, where you select the type of installation preferred for MSDN. There are three different
types of installation, which are:
TypicalInstalls commonly used components of MSDN
CustomAllows you to install only the components that you select
FullInstalls the entire MSDN Library to your hard disk
In most cases, Typical installation is what youd choose. This installation takes up a maximum of 60MB of hard disk space, as opposed to the
800MB used by Full installation. As you choose only the components that you want installed with Custom, the amount of disk space required
depends on the components youve decided to install. If you have significant disk space available, it may be worthwhile to perform a full
install of MSDN. This will provide you with better search capabilities when using the library.
Figure 1-4: Choose the type of installation that you want for the MSDN Library
After clicking Typical or Full, the setup wizard will check the hard disk where MSDN will be installed to ensure there is enough hard disk
space. It will then begin copying the necessary files onto your hard disk, until finally displaying a message box that informs you whether the
installation succeeded or failed.
If you decide to perform a Custom installation of MSDN, the next screen you see will be a listing of documentation and samples that can be
installed onto your hard disk. This includes information on Visual C++ 6.0, as well as items related to other products in the Visual Studio
suite. Its advisable that you install items related to the programs youre using, as these will provide you with important information and
online assistance. Once youve selected the items to install, clicking Next will begin the transfer of files from the CD-ROM to your hard disk.
A message box will then display whether the installation succeeded or failed, and indicate the end of this portion of the installation process.
Once youve installed MSDN, youre ready for the final step in the installation process. This is deciding whether to install InstallShield. As
we saw earlier in this chapter, InstallShield is a program used when setting up installation packages for programs created with Visual C++ 6.0.
It appears in a Client Tools listing on the Other Client Tools screen that appears next. By selecting InstallShield from this listing, the Install
button on this screen then becomes enabled. You can click this button, and InstallShield will be begin its own installation process on your
computer.
A welcome screen will appear for the InstallShield installation wizard, and by clicking Next youre brought to the InstallShield Software
License Agreement screen. By clicking the Yes button on this screen, you can proceed with the installation. Otherwise, your only other
choices are to click Back to move to the previous screen, or No to cancel the installation.
The following screen will display your name and company name, which is filled in already from information in the Windows Registry. Ensure
Cha 01:
that this information is correct, as you wont be able to change it later. Following this, click Next to continue.
The Choose Destination Location screen allows you to specify where InstallShield will be installed. You can either accept the default
installation folder, or click Browse to open a new dialog box. This dialog box enables you to specify a different directory to install to. As with
the Browse dialog box we saw earlier, you can type a path where InstallShield will be installed, or use the dialog box to browse your local
computer or network drive. If you type a path to a folder that doesnt exist, youll be prompted as to whether the wizard should create this
directory.
Click Next from the Choose Destination Location screen and you will then be asked to specify how InstallShield should be installed. There
are three setup types to choose from:
TypicalInstalls the most commonly used options. This is the option used by most users of InstallShield
CompactInstalls the minimal options for using InstallShield. This should be used if you have limited disk space
CustomEnables you to specify which options youd like to install
Selecting either Typical or Compact will take you to a screen informing you that youre ready to begin installing, and tells you what the
Installation Wizard will do next. Well discuss this in the paragraphs that follow. Clicking Next will begin copying the necessary files to your
hard disk. However, if you select Custom, you will have a few more choices to make.
Exam Watch: Although most installations will involve choosing the Typical installation type, you should be aware of what can be installed on
your system. This can be seen through the Custom installation, which can show you the individual components available to install.
Clicking Custom from the Setup Type screen brings up a new screen where you can choose which options will be installed on your computer.
There are three options on this screen:
Program FilesThe application files necessary to use InstallShield
Help FilesDocumentation files that provide online assistance
TemplatesSamples that can be used with InstallShield
A check box appears before each of these options, and clearing a check box will mean that that particular option wont be installed. If a check
box is selected, then that option will be installed.
Clicking Next brings up the previously mentioned screen that informs you that installation is ready to begin, and tells you what will take place
next. This screen informs you that a shortcut to InstallShield will be added to the Start menu, and that it will also be accessible from the Tools
menu of Visual C++. Clicking Next will begin installation of files from the installation CD-ROM, based on the options you choose earlier.
The final screen in the installation process includes an option to view a README file associated with InstallShield. To view this file, leave
the check box selected. Otherwise, click the check box to clear the check mark. Click Finish.
Server Tools
Once installation of InstallShield has completed, the installation process shifts from client tools to server tools. It is here that you can select
individual server tools from a listing of server components. This is the same screenshown in Figure 1-5that appears if you selected Server
Tools as the installation type mentioned early in the installation process. Once youve selected a component from the Server Components
listing (by clicking the name of the component to install), the Install button becomes enabled. Clicking the Install button invokes an
installation wizard for the component selected.
Figure 1-5: Choose the server tools to install from the Server Setups screen
If youre installing these server tools on Windows NT, Microsoft recommends that all of the tools be installed. Each of these tools can be used
Cha 01:
for developing applications with Visual C++ 6.0. If youre installing these programs on a Windows NT system, then the order in which you
install these products is up to you.
This is a little different from installing the server tools on a Windows 9x system. Windows 95 and Windows 98 require some of these server
applications to be installed before others, if your installation is to succeed. The order is as follows:
1. NT Option Pack (for Windows 9x)
2. FrontPage 98 Server Extensions
3. Data Access Components 2.0
4. Visual InterDev Server Components
5. Application Performance Explorer
6. Visual Studio Analyzer
The remaining two components, Visual SourceSafe Server and Visual FoxPro Server Samples, can be installed in any order. This is because
they dont rely on any of the other components to be installed beforehand.
Exam Watch: An easy way to remember the order in which server tools should be installed on a Windows 9x system is with the following
sentence: On Fun Days, I Am Awesome. The first letter of each word represents one of the tools: Option pack, FrontPage extensions, Data
access, InterDev components, Application performance explorer, and (Visual Studio) Analyzer. At the very least, this will help you remember
the order until you get into the exam, and can jot it down on paper.
Once youve installed the individual server tools, by following the on-screen instructions of each individual setup wizard, you can then click
the Next button and go to the final screen of the installation process. A check box appears on this screen indicating whether you would next
like to register Visual Studio online. If you have a modem and Internet access, clicking the Finish button will take you to a Web site where
you can register Visual Studio. If you dont have these requirements, then click the check box to clear the check mark. Finally, click Finish to
complete the installation.
Exercise 1-1 Installing Visual C++ Development Tools
1. Insert your Visual Studio installation CD-ROM into your CD-ROM drive. The setup wizard should start immediately. If it doesnt
appear after a minute or more, open Windows Explorer (or NT Explorer if youre using Windows NT), and select your CD-ROM drive to
browse. Double-click on the SETUP.EXE file in the root directory.
2. When the welcome screen appears, click the Next button.
3. The End User License Agreement screen will appear next. Select the I accept the agreement option, if you wish to continue with the
setup. Click Next.
4. When the Product Number and User ID screen appears, enter your product ID number (CD Key). Ensure that your name and companys
name is correct, then click Next.
5. If you have previous versions of Visual C++ or other Visual Studio products installed on your computer, a screen will appear asking if
you want these previous versions removed and replaced with new versions that youre installing. If you clear the check boxes beside the
products that you wish to keep, those products wont be uninstalled. Click Next to continue.
6. Select the Products option, then click Next.
7. The screen that appears asks you to specify a folder that will be used for files commonly used by multiple products. Accept the path
entered in the field provided, or enter the path to where youd like common files to be stored. Click Next.
8. When the installation welcome screen appears, click Continue.
9. Write down the product ID number on a piece of paper, and keep it in a safe place for future use. Click OK to continue.
10. The next screen that will appear is the Custom screen. Here you can specify which products and tools will be installed. Click the Visual
SourceSafe check box to clear the check mark. We will be installing Visual SourceSafe in the next chapter. Accept the remaining
preconfigured options selected in the listing, and click the Continue button.
11. After the setup wizard finishes copying files and making modifications to your system settings, youll be prompted to restart the
computer. Click the Restart Computer button on this message box to continue.
12. When your computer restarts and reloads Windows, a new screen will appear asking if you want to install MSDN. Insert the MSDN
CD-ROM into your CD-ROM drive. Ensure that the Install MSDN check box is selected, and then click Next.
13. When the MSDN welcome screen appears, click Continue.
14. Another product ID screen will appear, displaying the product ID number for MSDN. Document this number, then click OK.
15. When the End User License Agreement for MSDN appears, click the button labeled I agree to continue with the installation.
16. When the MSDN Installation screen appears, click Typical. MSDN will then proceed installing its files onto your hard disk. When it has
finished this, click OK on the message box that appears, telling you whether your installation was successful or not.
17. Select InstallShield from the listing of Client Tools shown on the Other Client Tools screen that appears, then click the Install button.
18. When the InstallShield welcome screen appears, click Next.
19. To continue with the installation process of InstallShield, click the Yes button on the InstallShield Software License Agreement screen
that appears.
20. Accept the default folder where InstallShield will be installed, or click Browse to specify a new target directory. Click Next to continue.
21. Click Typical to install InstallShield with the most commonly used features.
22. Click Next to begin the installation. Files will then begin to be transferred to your hard disk, and InstallShield will be installed.
Cha 01:
23. When the files have been copied to your hard disk, a final screen for this portion of the installation will appear. If you wish to read the
README file associated with InstallShield, leave the check box selected that is beside Yes, I want to view the Readme file. Otherwise,
click the check box beside this option to clear the check mark. Click Finish to complete the InstallShields installation.
24. From the Server Setups screen, select the components you wish to install. If youre installing onto a Windows NT computer, install each
of these components (as Microsoft recommends). If youre installing onto a Windows 9x computer, install the server tools in the order given
in the Server Tools section of this chapter. Follow the on-screen instructions for any server tools installed, then click Next from the Server
Setups screen to continue.
25. The final screen of the installation process appears. This screen has a check box to indicate whether you would like to register Visual
Studio online. If you have a modem and Internet access, clicking the Finish button will connect you to a Web site. If you dont have a modem
and Internet access, click the check box to clear the check mark. Click Finish to complete the installation.
Service Packs
As mentioned earlier, service packs can be installed to resolve issues associated with a particular product. These issues may be legal (as was
the case with Visual J++), bug fixes, or other problems that werent realized or couldnt be fixed when the product was initially released. After
software has been installed, you can install the service pack. This will install updated files that deal with those problems.
Exam Watch: Dont expect to see much, if anything, regarding the service packs on your exam. The vast majority of questions that could
appear on your exam were written before the service packs became available. Despite this, you should be aware of service packs, and install
them to avoid problems that could result after installation. The reason the service packs exist are to upgrade problematic files
In the case of Visual Studios Service Pack 3, numerous issues are dealt with. One in particular is a bug in Visual C++ that can cause memory
problems and crash third-party software. This bug appears in all editions of Visual C++ and Visual Studio. To deal with this problem, Service
Pack 3 replaces a file associated with the heap manager (MSVCRT.DLL). Other upgraded files dealing with Visual C++ and other products
are also included in the service pack.
Because the service pack upgrades files on your system that may be used by applications you create with Visual C++, its important to install
the service pack as soon as possible. This will ensure that any programs you create with Visual C++ 6.0 will have the latest files included with
them, and keep users of your applications from encountering problems. As well see later in this book, such files may be included with
applications you create and distribute.
Although there are three Visual Studio service packs at the time of this writing (that is Service Pack 1, Service Pack 2, and Service Pack 3),
you dont need to install all of them. Not only does Service Pack 3 resolve all of the issues taken care of in Service Pack 1 and 2, but it
addresses additional problems that were solved after the initial release of Visual Studio and the first two service packs. As they deal with
known issues that have been resolved since your installation CD-ROMs release onto the market, you wont find the service pack on this
CD-ROM. You need to obtain it from Microsoft. This can be done by contacting them directly, or by visiting the Visual Studio Web site at
msdn.microsoft.com. As well see in the exercise that follows, it is from here that youll be able to download the latest service pack.
When installing Service Pack 3, you should first shut down any Visual Studio products youre using. If, for example, Visual C++ were open,
problems could arise when the service pack overwrites files associated with that program. Once the service pack has finished installing, you
can then restart any of the Visual Studio products you were using.
Unfortunately, because the service pack overwrites files associated with Visual Studio products, there is no way to uninstall just the service
pack. If there was, files would then be missing for products in the Visual Studio suite, and those products would be unable to function
properly. As such, you would need to uninstall the actual product to get rid of the changes made by the service pack. For example, to get rid of
the MSVCRT.DLL upgrade for Visual C++, you would need to uninstall Visual C++. Upon reinstalling Visual C++, any changes made by the
service pack for Visual C++ would be gone.
Exercise 1-2 Obtaining and Installing the Visual C++ Studio Service Pack
1. Open Microsoft Internet Explorer by double-clicking the shortcut on your desktop. After connecting to the Internet, type the URL
http://msdn.microsoft.com/vstudio/sp/default.asp in the address bar. If you have trouble connecting, go to the MSDN Web site
(http://msdn.microsoft.com), then click the link on this page for the latest service pack.
2. Click the hyperlink for the Full install of the service pack.
3. Click each link for a service pack file from one download site. For example, at the time of this writing, the latest service pack is Service
Pack 3. This means you would download each of the following from one location: VS6SP3_1.EXE, VS6SP3_2.EXE, VS6SP3_3.EXE, and
VS6SP3_4.EXE. For each files hyperlink that you click, select Save this program to disk when prompted to download the software, then
click OK. Following this, select a directory on your hard disk to which you will download the files.
4. After download has completed, run each of the files you downloaded. This can be done by either entering the path and filename of each
downloaded file, or by using Windows Explorer. You can start Windows Explorer (or NT Explorer if youre using a Windows NT system)
from the Programs folder of the Start menu. Use the browser to go to the directory in which you saved these files, and double-click each of the
downloaded files. The contents of each of these files will expand upon being opened.
5. Run the SETUP.EXE program that has been expanded from the downloaded files.
6. When the End User License Agreement screen appears, click I Accept to install the service pack.
From the Classroom
VC++ just keeps getting better!
For the Visual C++ developer seeking to obtain the C-enriched track of the new Microsoft Certified Solution Developer (MCSD) credential,
the process will most likely begin with Exam 70-016, Designing and Implementing Desktop Applications with Microsoft Visual C++ 6.0.
Don't be fooled by the desktop spin, this exam will cover many general aspects of C++ coding and will require a definite comfort level with
the Visual C++ 6.0 environment. Although this may seem basic, it is absolutely recommended that trivial issues such as familiarity with the
integrated development environment (IDE) be eliminated in the beginning, prior to focusing on the technical specifics of the coding, the
syntax, and the tool usage. Once IDE familiarity is obtained, you can focus on the more complex utilities such as the Source Code Profiler,
Cha 01:
Visual Database tools, or the Component and Object Gallery.
The process should begin with selecting the appropriate version of Visual C++ 6.0 (Standard, Professional, or Enterprise). After installing it
on your machine, it is time to make yourself at home in the Visual C++ IDE. There are many options available that allow the developer to
customize the user interface for Visual C++. One easy way that you can become more comfortable with the development environment is to
change the appearance and placement of toolbars to meet your personal tastes.
Toolbars in Visual C++ contain buttons and menus that give you access to the wide array of commands that you will use to build and deploy
your applications. Microsoft has gone to great lengths to provide a uniform look and feel to all of the members of the Visual Studio suite of
development tools. Factors that influence how you arrange toolbars include screen size, what commands you most commonly utilize, as well
as personal preferences. To make a toolbar docked or floating, just right-click the toolbar and toggle the docked property. While the toolbar is
floating, make note of its name in the title bar. You can use this name to display or suppress the toolbar by selecting it or canceling its
selection from the pop-up menu that appears when you right-click any toolbar. The Customize menu option provides a convenient way to turn
a number of toolbars on and off at the same time. After selecting Customize from the toolbar pop-up menu, select the Toolbars tab of the
dialog box that is displayed; here you can select or cancel the selection of as many toolbars as you like. Sometimes when you are dragging
toolbars around, they will unexpectedly dock as you drag over certain areas. To avoid this behavior, just hold down the ctrl key while you
drag the toolbar to its desired location.
There are numerous ways to customize the Visual C++ environment. Other examples include creating custom-highlighted keywords,
customizing the debugging interface, assigning commands to shortcut keys, and customizing the text editor by emulating another editor. After
getting acquainted with the basic features of Visual C++, you should spend a little time modifying the user interface to suit your specific
development needs and style. Customizing the user interface will lead to a greater level of comfort and a better understanding of the Visual
C++ environment.
Michael Lane Thomas, MCSE+I, MCSD, MCT, MCP+SB, MSS, A+
Certification Summary
Visual C++ 6.0 can be acquired on its own or as part of the Visual Studio suite of products. Visual Studio not only includes Visual C++, but
also Visual Basic, Visual J++, Visual InterDev, Visual FoxPro, and various tools helpful in creating robust applications rapidly. On its own or
as part of Visual Studio, different editions are available. Visual Studio is available in Professional and Enterprise editions, while Visual C++ is
available in Standard, Professional, and Enterprise editions.
Before attempting to install Visual C++ 6.0 (or any other software for that matter) onto your computer, you should ensure that the minimum
system requirements are met. These are the bare minimumin terms of RAM, processor, disk space, and so forththat your computer will
need to install and run Visual C++ 6.0. These may vary from edition to edition of Visual C++ 6.0. If your system meets these requirements,
then you can be sure that no problems will result from unsatisfied requirements. If these arent met, Visual C++ 6.0 may not install and run
properly.
Installing Visual C++ through Visual Studio is a multipart process. It starts by starting the setup wizard, which gathers information about your
computer and asks for input from the installer. It is highly interactive, enabling you to choose the type of installation you wish to do, the
products to install, and where to install them. It then moves into installing the MSDN Library and InstallShield, and allows you to install
various server tools.
Once installation is complete, you should check the MSDN Visual Studio Web site to obtain and install the service pack. This will upgrade
your installation with files that resolve known issues about Visual Studio products, inclusive to Visual C++ 6.0. By not installing the service
pack, you may encounter bugs or problems, and wont be redistributing the latest files with applications that you create.
Two-Minute Drill
Visual C++ 6.0 can be purchased by itself, or as part of the Visual Studio suite of products.
Visual Studio not only includes Visual C++, but also Visual Basic, Visual J++, Visual InterDev, Visual FoxPro, and various tools
helpful in creating robust applications rapidly.
Visual C++ 6.0 is also available in three different editions: Standard, Professional, and Enterprise
Knowing the individual components of Visual Studio or Visual C++ is not a direct objective of the exam. However, knowing this
information can be useful in understanding whats being asked in a question.
Although its cheaper to purchase Visual C++ 6.0 on its own, Visual Studio comes with significantly more development tools.
Visual Studio is a suite of products used for developing and managing applications, components, and data access. It provides you with a
wider scope of options than Visual C++ alone, because it contains more than just Visual C++ 6.0.
As part of Visual Studio, or on its own, Visual C++ 6.0 includes a number of features that can be used for creating desktop and
distributed applications
Visual C++ 6.0 supports the Component Object Model (COM). This is an object model that enables various software
componentsapplications, controls, data objects, services, and so forthto interact as objects. These objects contain data, and provide a
method through which other components can access that data.
Visual C++ 6.0 includes a large number of prebuilt, ready to use ActiveX controls. New to Visual C++ 6.0 are composite controls. These
are new controls that you can create by combining your existing ActiveX and Windows controls.
Although minimum installation requirements arent a specific objective of the exam, it is an important part of installing Visual C++ 6.0
Development Tools, which subsequently is an objective. Many installation problems are due to the fact that the system fails to meet the
minimal requirements of the software youre attempting to install.
Before taking the exam, make sure you understand the minimal requirements for each edition of Visual C++ 6.0, on both Windows 9x
and Windows NT. This will help you analyze problems being discussed in exam questions, and determine why a certain installation is failing.
For each edition of Visual C++, the operating system requirements are the same. You need to be running Microsoft Windows 9x or
Windows NT version 4.0 or higher. However, if youre using Windows NT, youll need to install Service Pack 3 (SP3), which is included on
the Visual C++ installation CD-ROM.
Cha 01:
Remember that just because a product or feature comes with a package, it doesnt necessarily mean that you need to install it. If you
dont need certain features or products included with an edition of Visual C++, then youre generally better off not installing them. This will
leave you free hard disk space to install software that you do need.
Although reading about how to install Visual C++ 6.0 will give you the knowledge of how the installation process works, you should
reinforce this knowledge by actually going through the steps hands-on.
It can be confusing when the Custom screen appears after selecting the Products installation type, which sets you on the track of doing
preconfigured installations of products. Remember that the Products installation type sets up the necessary options on the Custom screen, and
in this way is different from the Custom installation type.
The Microsoft Developer Network (MSDN) Library is a collection of documentation and samples for the Visual Studio suite of
products. If youre installing from Visual Studio, MSDN is included.
Although most installations will involve choosing the Typical installation type, you should be aware of what can be installed on your
system. This can be seen through the Custom installation, which can show you the individual components available to install.
Once installation of InstallShield has completed, the installation process shifts from client tools to server tools. It is here that you can
select individual server tools from a listing of server components.
An easy way to remember the order in which server tools should be installed on a Windows 9x system is with the following sentence:
On Fun Days, I Am Awesome. The first letter of each word represents one of the tools: Option pack, FrontPage extensions, Data access,
InterDev components, Application performance explorer, and (Visual Studio) Analyzer.
Service packs can be installed to resolve issues associated with a particular product. These issues may be legal (as was the case with
Visual J++), bug fixes, or other problems that werent realized or couldnt be fixed when the product was initially released.
Dont expect to see much, if anything, regarding the service packs on your exam. The vast majority of questions that could appear on
your exam were written before the service packs became available. Despite this, you should be aware of service packs, and install them to
avoid problems that could result after installation.
Not only does Service Pack 3 resolve all of the issues taken care of in Service Pack 1 and 2, but it addresses additional problems that
were solved after the initial release of Visual Studio and the first two service packs.
By not installing the service pack, you may encounter bugs or problems, and wont be redistributing the latest files with applications that
you create.
After getting acquainted with the basic features of Visual C++, you should spend a little time modifying the user interface to suit your
specific development needs and style.
Cha 01:

Chapter 2: The Development Environment
Visual SourceSafe Installations. 6
Configuring Visual SourceSafe. 17
Using Visual SourceSafe. 27
Multiple User/Multiple Location Development 33
Versioning of the Source Code. 34
Two-Minute Drill 50
Source Code Control
Using Microsoft Visual SourceSafe
MFC Wizards
Resource Editors
Using the Gallery
Information Resources
In this chapter well discuss a number of issues relating to the development environment. Specifically, well talk about using source code
control in Visual C++ 6.0, and how you can use Microsoft Visual SourceSafe (VSS) to keep your source code safe and accessible. Well also
talk about using resource editors and wizards to create and manipulate source code created with Visual C++ 6.0.
Visual C++ 6.0 comes with a number of elements that aid you in creating robust applications. In addition to wizardswhich take you
step-by-step through the process of tasks like creating specific files for your applicationswell talk about the Gallery and information
resources available through Visual C++. The Gallery contains prepackaged components and registered ActiveX controls that can be added to
your projects. A project is a collection of files that make up your application. Information resources aid you in finding answers to problems
quickly and efficiently.
Source Code Control
Controlling source code is an issue regardless of whether youre programming by yourself, or with a team of programmers. Source code is the
programming code you write, which makes your program actually do things (that is, make calculations, open and close files, display data, and
various other operations). As you or others make changes to source code, there may be times when youll need to track those changes. You or
another programmer may modify the code, only to find that these changes adversely effect your application. You may want to refer to a
previous version of your application to see how it was originally written, or to see if you should revert to previously used code. Tracking
changes to source code during software development enables you to see what work has been done and who has done it. Tracking changes
helps you analyze how those changes have affected the project as a whole. Although there are many reasons why you may wish to do this,
source code control is required for you to track changes and restore previous versions of code.
On the Job: Some people may get the wrong idea about the benefits of VSSs ability to track changes, and may think it akin to Big Brother
watching. The fact is that if youre modifying code that someone else has worked on, you may have questions. Through this feature in source
code control, youll be able to find who last worked on it to get the answers you need. This will keep you from adversely changing aspects of
code, thinking its no longer needed. If youre working on a component that works with others in a project, youll be able to find who last
worked on a particular component and consult them. This is particularly beneficial on large projects, where there may be a number of
developers working on a single project.
To facilitate source code control, Visual C++ 6.0 uses the Microsoft Source Code Control Interface. This interface provides a method for
source code control systems such as Visual SourceSafe (which well discuss later in this chapter) to integrate with the Visual C++
environment. This means that although the source code control system is a separate application, you can access aspects of its functionality.
Through menu items in Visual C++ 6.0, youre able to invoke operations performed by the control system. This includes saving your projects
and source code files to the control system (such as a Visual SourceSafe database), removing them, examining their history, determining the
status, and so on.
After installing Visual C++ 6.0, you may have looked for commands or dialog boxes dealing with source code control. If you did, you may
have been surprised to see that nothing was there. This is because the commands associated with source code control dont appear until a
source code control system is installed. As Figure 2-1 shows, these menu items only appear after the control system is installed. In addition,
the installed control system must conform to the Microsoft Common Source Code Control Interface. If the control system is installed and it
has been designed to conform to this interface, a number of menu commands will appear, as will a new tab in the Options dialog box. If it
doesnt conform, then the menu items and the tab in the Options dialog box wont appear at all, and it will seem as if no control system has
ever been installed.
New Page 6
Figure 1: Source code control commands appear in the menus after the control system is installed
As well see when we discuss Visual SourceSafe, the menu items and the Options dialog box in Visual C++ 6.0 dont provide complete
control over the source code control system. Each and every feature provided by the source code control system isnt available through the
menu items in Visual C++ 6.0. Certain administrative tasks are done through the source code control systems administrative program. In
addition, there are some tasks that need to be done with tools associated with your operating system. An example of this is assigning
permissions for drives and directories. On a Windows NT Server, this is done through User Manager for Domains. Such permissions prevent
developers from accessing directories or drives containing code that doesnt apply to their individual projects. This gives you an additional
level of control, beyond the functionality of whats included in Visual C++ 6.0 with source code control installed. By designating one or more
people to administer source code control for other developers on your team, you can keep them from having the access to do more than they
should.
Using Microsoft Visual SourceSafe
Visual SourceSafe (VSS) is a source code control system, which allows developers to save copies of their source code to a database. When a
file is added to VSS, that file is stored in the VSS database. The database supports many different file types, including binary files, graphics,
text files, audio, and video. If the original file becomes corrupt, or modifications that dont work are made to the source code, it doesnt
necessarily mean that your previous, functional source code is lost. You can use VSS to restore old versions of files by retrieving them from
the database. You can also view information on each version that is stored in the database. This gives developers the ability to track any
changes made to their source code files.
As with any software, the first step toward using Visual SourceSafe 6.0 is installing it. The Visual Studio installation CD-ROM comes with
two setup options for VSS:
Visual SourceSafe Client installation
Visual SourceSafe Server installation
In installing these, you may think that the client and server installations of VSS are identical. As well see, they are not. For development
teams to use and get the full benefits of VSS, both of these installations must be performed.
The VSS Client installation is done on machines where users wish to save their source code to the database. Because it is a Microsoft product,
VSS conforms to the Microsoft Source Code Control Interface. This means that when the VSS Client is installed, the commands dealing with
source code control will be added to the Visual C++ 6.0 environment, as will a new tab under Visual C++ 6.0s Options dialog box. It is
through these that youll be able to interact with VSS. Any workstation that will use the VSS database will need to have this client portion
installed.
The client installation can be installed at the same time you install Visual C++ 6.0. In referring back to the installation of Visual C++ 6.0 in
Chapter 1, youll remember that this appears on the Custom screen during setup, and is available for installation by selecting Visual
SourceSafe 6.0 during the Products installation type. When this is selected (by clicking to check the check box beside this entry), the VSS
client installation will be performed. As well see later in this chapter, you can also install VSS after Visual C++ 6.0 has been installed.
The Visual SourceSafe server installation is used to install a source code control database that stores versions of source code. It also installs an
administration application that will enable you to control who can access the source code files stored in the database and control who can
perform administration tasks.
The client portion works with the server portion of VSS. Through the client portion of VSS, developers can save and retrieve their source code
from this database. As all members of the development team can use this database, the server installation only needs to be performed once on
a network. The client portion, however, needs to be installed on each and every computer that will access this database. This includes the
server itself if it will be used for development work. Despite the fact that you have the server portion installed on a server machine, youll still
need to install the client portion on that machine if youre going to develop applications on that machine. Remember that the client portion is
used for all developers accessing the source code control database, whereas the Server portion provides a centralized database and
administration. To use VSS on the computer thats acting as the VSS server, youll also need the VSS client installed.
Like the client portion, you can install the VSS server when Visual C++ 6.0 is installed through Visual Studio. If Visual C++ 6.0 has already
been installed, you can still install VSS Server. In both cases, this is done through the Server Setups screen of the Visual Studio installation.
As well see later in this chapter, when you select Visual SourceSafe Server from the listing of available client tools on this screen, a new
wizard will start that directs you through the installation process.
New Page 6
Visual SourceSafe Installations
As mentioned, there are two installations that are performed when installing VSS. Unlike some other development systems, however, you can
perform these installations either before or after installing Visual C++ 6.0. Regardless of the order, source code control features will be
integrated with the Visual C++ 6.0 development environment. This is different from Visual Basic, for example, where the development
system needs to be installed before VSS.
Installing Visual SourceSafe is a two-part process. The first step is installing the VSS server, which will provide developers with a centralized,
source code control database. This is generally installed by the person who is the designated VSS administrator, and who will be responsible
for the administration tasks well discuss later in this chapter. The second part of the process is installing the client portion on each
workstation that will access this database. As well see later in this section, the administrator or individual users may be responsible for
installing the VSS client software.
Regardless of whether you perform a client or server setup of VSS, new folders will be added to your hard disk during the installation. Many
of these folders and the files contained within them are similar for each installation. As well see in the paragraphs that follow, you are given
an opportunity during the installation to choose the name and location of the folder that VSS will install to. However, the subdirectories within
this directory will vary, depending on whether a server or client installation is chosen.
On the Job: Its important that you understand what resides in each of the folders created by VSS during installation. This will allow you to
quickly find applications and files needed when administrating VSS.
Only the \Win32 and \Setup folders are installed during the client installation. The \Setup folder contains installation files, which can be used
to install additional components or uninstall VSS. The \Win32 folder contains Administration and other 32-bit Intel programs that can be used
on Windows 9x or Windows NT machines. Well discuss these applications in greater detail later in this chapter.
The server installation installs a large number of folders and files. These include a User folder that stores initialization files for various VSS
users, a \Data folder for the database, a Temp folder used to store temporary files, and an \NetSetup folder for the NetSetup installation
discussed in this section. A Template folder will also be installed containing templates of initialization files used by VSS. In addition, folders
installed in the client installation are also added. These include \Setup and \Win32. The \Setup folder contains installation files, which can be
used to install additional components or uninstall VSS. The \Win32 folder contains Administration and other 32-bit Intel programs that can be
used on Windows 9x or Windows NT machines.
Exam Watch: Remember that of the folders created in client and server installations of VSS, the \Win32 and \Setup folders are common to
each. The \Win32 directory contains tools needed to use VSS effectively, while \Setup is used for installing additional components or
removing VSS from a system.
Visual SourceSafe Server is installed through the Visual Studio installation CD-ROM, which we used in the previous chapter. To start the
Installation Wizard, you must insert your installation CD-ROM into your CD-ROM drive, and then use Windows Explorer to double-click the
SETUP.EXE file on this CD-ROM. Although this is the same procedure used in Chapter 1 to start the Installation Wizard, the first screen that
appears will be different. As Figure 2-2 shows, the first screen explains that the wizard recognizes that other Visual Studio products have been
installed. It also gives several options of installation types.
Figure 2: The Installation Wizard recognizes that other Visual Studio products have been installed
The Workstation tools and components option is chosen when you want to install additional products that come with Visual Studio. This not
only includes Visual C++ 6.0 and other development systems, butas well see later in this sectionit is also the option chosen when
performing a Visual SourceSafe Client installation. In addition to products, you can also select the Other Microsoft tools option to install
InstallShield, or MSDN to install the Microsoft Developer Network Library.
The Server applications and tools (add-only) option is selected when you wish to install various server applications. When installing VSS
Server, you select this option and then click the Next button. This will take you to the Server setups screen, where you will begin installing
VSS Server.
New Page 6
The Server setups screen provides a listing of server applications to install. Although theyre called server applications, this doesnt
necessarily mean that you cant install them on a workstation. The Visual SourceSafe Server can be installed on any Windows 9x or Windows
NT machine. Once installed, other workstations on the network can access the source code database available through this installation.
Select Visual SourceSafe Server from this screen, then click the Install button. This starts the VSS Server Installation Wizard. Youll be asked
to switch the current CD-ROM inserted in your CD-ROM drive with the second installation disk. Clicking the OK button on this prompt will
begin the installation process, and display a welcome screen.
Clicking the Continue button on the welcome screen will cause a second screen to appear. This screen displays a product ID number. You
should document this number, as it may be requested if you contact Microsoft for assistance. After installing VSS Server, youll be able to
access this number from the dialog that appears upon clicking About Administrator from the Help menu of the Visual SourceSafe Admin tool.
Well discuss the Admin tool later in this chapter, but its important that you document this product ID number during the installation. If the
Admin tool doesnt run, this will be your only chance to document it. Once youve written this number down, click the OK button to continue.
At this point, a small dialog box will appear. This is your last chance to back out of installing VSS Server by clicking Cancel. By clicking the
button labeled Server on this dialog, youre indicating that you want to install VSS Server to your computer.
When you click Server, a small message box will appear. This box asks whether all clients will be using this database with version 6.0 of the
client software. This is the client portion of VSS that comes with Visual Studio 6.0 and Visual C++ 6.0. If they are, you click the Yes button
on this message box, and a database compatible with version 6.0 will be used. If some users will be using previous versions of the VSS client,
click the No button. This indicates that version 5.0 client software will be used. This may decrease the performance of VSS Server, as the
database and components for version 6.0 client software is faster. If this is the first time youll be using Visual SourceSafe with development
systems, then you should click Yes, as well be installing the client software next.
Once youve answered the yes or no question of this screen, the wizard will begin transferring files to your computer. It will also make the
necessary changes to your system settings, and add entries related to VSS Server to your Windows Registry. When this is complete, a small
message box will appear stating whether the installation was successful or not. After clicking OK on this message box, you should be ready to
begin installing client software and configuring Visual SourceSafe.
Exercise 2-1 Installing Visual SourceSafe Server
1. Insert your Visual Studio installation CD-ROM into your CD-ROM drive. Using Windows Explorer, double-click the SETUP.EXE file
on this CD-ROM.
2. Select the Server applications and tools (add only) option, then click Next.
3. From the listing of Server components appearing on the Server setups screen, select Visual SourceSafe Server. Click the Install button
4. When prompted, insert the second Visual Studio installation CD-ROM, then click OK.
5. When the Visual SourceSafe Server welcome screen appears, click the Continue button.
6. When the Visual Source Safe Server setup screen appears, showing a product ID number, document the product ID number, then click
OK.
7. Click the Server button that appears on the screen that follows.
8. Click the Yes button if everyone using this VSS database will be using version 6.0 client software. If you have previous versions of
Visual C++ installed that use version 5.0 client software, click No.
9. The wizard will then begin transferring files. When it has completed, click OK. When prompted to restart Windows, click Yes.
10. You will return to the Server setups screen. Click Finish to complete the installation process.
After Visual Studio has been installed, you can still perform a Visual SourceSafe Client installation by using the Visual Studio Installation
Wizard. In doing so, Visual C++ 6.0 and other development systems previously installed through Visual Studio will become integrated with
the source code control system. As stated previously, this means that youll be able to access the source code control database of VSS through
commands in Visual C++ 6.0.
There are three ways of starting the VSS Client installation after Visual Studio and Visual SourceSafe Server have been installed. These are as
follows:
Using the Add/Remove Programs applet in the Windows Control Panel
Starting SETUP.EXE from the Visual Studio installation CD-ROM
Using the NetSetup program thats located in the folder that you installed from Visual SourceSafe Server
In the paragraphs that follow, well discuss each of these methods. This will provide you with clear insight of how each of the client
installations can be performed.
As we saw when installing Visual SourceSafe Server, you can start installing Visual SourceSafe Client by inserting your Visual Studio
CD-ROM into the CD-ROM drive, and running the SETUP.EXE program. This displays a screen with various installation options, which was
shown earlier in Figure 2-2. By clicking the Workstation tools and components option and clicking Next, youll be brought to the
Maintenance screen shown in Figure 2-3. From here, youll be able to select additional products and tools to install.
New Page 6
Figure 3: From the Maintenance screen, you can select the products and tools that you want to install
This isnt the only way to start the Installation Wizard and get to this screen. After Visual C++ 6.0 has been installed onto a computer, you can
add and remove different Visual Studio products with the Add/Remove Programs applet found in the Windows Control Panel. This applet is
accessed by selecting Settings from the Windows Start menu, clicking Control Panel, then double-clicking the Add/Remove Programs icon.
Add/Remove Programs will then open, and display a listing of previously installed applications. You then select Visual Studio from the listing
of installed programs, and click the Add/Remove button. This will open the Visual Studio Installation Wizard, and bring you to the
Maintenance screen shown in Figure 2-3.
The Maintenance screen of the Installation Wizard appears identical to the Custom screen we saw in Chapter 1. It enables you to add and
remove any of the client products and components in Visual Studio. This not only includes development and database applications, but also
the client portion of Visual SourceSafe. In the listing of options to add or remove, you simply click the check box beside the Visual
SourceSafe entry. If a check mark appears in the check box, then that indicates that the option has either been previously installed, orif you
just selected itthat the option is to be installed after you click the Continue button.
The wizard will check your system, and after its satisfied that there is enough disk space, the files related to this installation will be
transferred to your hard disk. Upon the completion of this transfer, a message box will appear, showing whether installation was successful or
not. If successful, youre ready to configure VSS for use. If not, you may need to rerun the Installation Wizard.
Although installing the Visual SourceSafe Client from a CD-ROM is effective, it is not the only way of performing an installation. There is
also the NetSetup method of installing the client portion. This is generally the recommended method of installing the VSS Client software, as
it allows users to install NetSetup over the network themselves. Whoever acts as VSS administrator doesnt need to be present with an
installation CD-ROM in hand. No installation CD-ROM is required when performing the installation because it uses the files in the Setup
folder residing in the folder that VSS Server was installed to. This is a benefit because the VSS administrator doesnt need to spend time
installing the client portion on every machine.
On the Job: The benefit of installing off the server applies not only to VSS administrators, but to most developers as well. If the VSS
administrator isnt given the task of installing the VSS Client to each developers workstation, individual developers (who have proper
permissions to the VSS Server directory on a server) will find it fast and simple to install over the network. Although many development
teams allow access to development toolsand would have access to the VSS installation CD-ROMthey would still require the proper
permissions and an account to access the VSS database.
As clients will be using the master database that was created when VSS Server was installed, NetSetup doesnt install a VSS database or
support files. It doesnt install an Admin tool, nor does it install a database, as the client portion is designed to use the services provided by the
VSS Server.
Although the CD-ROM installation can be performed either before or after Visual SourceSafe Server, NetSetup needs to be run after installing
VSS Server. A primary reason for this is because NetSetup is installed into the directory where you installed VSS Server. If you havent
installed VSS Server, then the NetSetup program hasnt been put onto your servers hard disk, and thereby cant be run.
Exam Watch: Since NetSetup is the recommended method of installing Visual SourceSafe Client software, you should be especially familiar
with this client installation type. Key points to remember are that NetSetup only installs the client portion, its run from the folder containing
VSS Server, no installation CD-ROM is required, and that users themselves can install VSS Client without administrator assistance. However,
because it uses the installation files in VSS Server, and NetSetup is installed with VSS Server, this means that you must first install VSS
Server before you can run NetSetup.
An exception to using NetSetup is when your network is experiencing heavy traffic. When NetSetup is used, the files transferred to the users
hard disk are sent over the network. If there is significant traffic, and numerous users are installing NetSetup, the network can become
seriously bogged down. When this is the case, you would want to perform a CD-ROM installation, or restrict the hours that users can install
through NetSetup.
You can begin installing the client portion of Visual SourceSafe over the network by using Windows Explorer (or NT Explorer if youre using
a Windows NT machine). By going to the folder in which you installed VSS Server, youll find a file called NETSETUP.EXE.
New Page 6
Double-clicking this file will start the NetSetup Installation Wizard.
As with most setup wizards, the first screen that youll see welcomes you to the Installation Wizard. Clicking the Continue button on this
screen will take you to the Name and organization screen. Here, youre required to enter your name, and the name of the company that you
belong to. The two fields on this screen will already have information entered in them, as the Installation Wizard retrieves the name and
company name from your Windows Registry. If this information is correct, click OK. Otherwise, correct the information, and then click OK
to continue. A message box will appear after this, confirming that the information you entered or accepted is correct. Clicking OK in this
message box will take you to the next step in the installation process, whereas clicking Change will take you back to the preceding screen.
The next screen shows the product ID number, which weve discussed when talking about other installations. Document this number, then
click OK to continue. This will cause the Installation Wizard to check your system for previous installations of Visual SourceSafe. If it finds a
copy, a dialog box will appear. It will state that an older copy has been found, but this necessarily doesnt mean that it is a previous version
of Visual SourceSafe. This same dialog appears if a current version is found. If you wish to overwrite the currently installed version, you can
click OK to continue. If youd like to keep this previous installation, you can click the Change folder button, and browse your local or network
drives for another folder to install to.
The next screen that appears gives you a final chance to change where Visual SourceSafe will be installed. Again, clicking the Change folder
button will enable you to browse your local or network drives for another folder to install to. To install the client portion, which allows you to
access a remote database, click the button that appears on this screen. Doing so will begin the transfer of files, and will install Visual
SourceSafe.
Exercise 2-2 Visual SourceSafe Client Installation
1. From the Windows Start menu, select Programs, and then click Windows Explorer (if youre using a Windows 9x system) or NT
Explorer (if your operating system is Windows NT). When Windows or NT Explorer starts, navigate your hard disk to the folder where VSS
Server has been installed. Double-click NETSETUP.EXE.
2. When the NetSetup welcome screen appears, click Continue.
3. Ensure that your name and company name are correct. If they arent correct, enter the correct information. Click OK to continue.
4. Click OK when NetSetup verifies that your name and company name are correct.
5. Document the product ID number, then click OK to continue
6. If the setup wizard detects that a previous version of Visual SourceSafe has been installed on your machine, and youre certain that this
is the VSS Server installation that we performed earlier, click the Change folder button. Enter a new path for the client installation to install to,
then click OK to continue.
7. When the screen appears with the licensing agreement, click Agree.
8. Click the Install button that appears on the next screen.
9. Wait as the Installation Wizard checks the availability of hard disk space, begins transferring files, and modifies your system settings.
When complete, click OK. This will bring up a prompt to restart Windows. Agree to this to finish the installation.
Configuring Visual SourceSafe
Once youve installed Visual SourceSafe, your work isnt quite over yet. You will still need to configure VSS, and create a list of users who
will be able to use the source code control system. This is done through the Admin program, which is formally called Visual SourceSafe
Administrator. This program (SSADMIN.EXE) is part of the VSS Server installation, and can be found in the Win32 folder in the folder
containing VSS. In addition to double-clicking this file, you can access it through the Windows Start menu. This is done by clicking Start,
selecting Programs | Microsoft Visual Studio 6.0 | Microsoft Visual SourceSafe, and then clicking Microsoft Visual SourceSafe Admin.
Starting the program will display the screen shown in Figure 2-4.
Figure 4: The Microsoft Visual SourceSafe Admin program lists the user information for the source code control system
New Page 6
A user list determines who has access to the source code control systems database. Through a user list, an administrator can add and delete
user accounts, assign rights, and change passwords. If a user doesnt have an account set up in this way, he or she wont be able to save or
retrieve files from the VSS database.
The Users menu of the VSS Administrator program contains various items that allow you to maintain the accounts of users. When you first
start this program, youll notice that two default accounts are already added to the user list. The person acting as VSS administrator uses the
Admin account, whereas users who dont have an account currently setup use the Guest account. When you first start the Admin program,
neither one of these accounts have passwords associated with them. You will be required to enter a password for the Admin account when you
first start the VSS Administration program. The Guest account doesnt have a password associated with it for good reason: because users who
dont have an account use it, numerous users may access VSS through this visitor account. As well see later though, you can
password-protect this account to limit accessibility. If youd like, you can also delete this account. The Admin account, however, cannot be
deleted.
The first step to setting up a user list is defining which VSS database your user list is for. Some users may have access to one database, but not
to another. As such, the Open SourceSafe database command on the Users menu is used to select and open a specific database. When this item
is selected, a dialog box opens that displays a list of current VSS databases. After selecting one of these databases, you can then click the
Open button to open that database. If you dont see the database that you wish to use, you can click the Browse button to browse local and
network drives for a specific database.
Once youve specified which database you want to use, you can use most of the other commands on the Users menu to control the user list
associated with that database. The Add user command on this menu adds a new user to the user list. The menu item displays a small dialog
box where you enter a user name and password. This will be used to identify the user when he or she logs in to VSS to use source code
control. If you dont want that user to be able to make changes to files and projects stored in the database, click the Read only check box. This
will allow the user to read information, but not to change it. Upon clicking OK, the user will be added to the user list.
When a new user is added, Visual SourceSafe creates a folder under /Users with that users name, containing a new SS.INI file for that new
user. This new file is based on the SS.INI file located in the /Users folder where VSS resides. This file is similar to the SRCSAFE.INI that
contains global variables that affect the VSS database. Although you can modify these files with any text editor, its not advised that you do so
unless youre familiar with what each entry in initialization file represents. User accounts should be modified through the commands available
in Visual SourceSafe.
Except for the Exit command (which closes the VSS Admin tool), each of the other commands in the Users menu can be used to modify or
remove a users account. These commands are:
Delete UserRemoves the selected users account from the user list
Edit UserDisplays a dialog box enabling you to change the user name of a selected user
Change PasswordDisplays a dialog box enabling you to change a selected users password
Each of these commands is used to modify the basic elements of the users account, which determine whether a user can use a specific
database. For more elaborate restrictions and modifications on a users account, you can use commands found in the Tools menu.
The Tools menu contains a number of commands that control both users and databases. First on this menu, are three commands determining
rights to data stored in the VSS database. These commands are as follows:
Rights by ProjectUsed to set rights on a particular project saved in the database
Rights Assignments for UserUsed to set a users rights
Copy User RightsUsed to copy another users rights to a selected users account
By default, these commands are disabled when you first use a new database. They appear shaded, and nothing happens when you click them.
This is because project security for the database hasnt been enabled.
Enabling project security is done through the Options dialog box, which appears when you select Options from the Tools menu. This dialog
box has a number of tabs, which are used to set the default behavior of VSS Administrator, as well as the databases and users maintained
through this tool. The Project Security tab has particular importance, as it determines what rights users have when new accounts are created.
Until the Enable project security check box has been selected on this tab, by clicking it, security is disabled. When selected, other options on
this tab become enabled, as do the three previously mentioned commands in the Tools menu.
When you Enable project security, the check boxes that become enabled on this tab are used to define the default rights of new accounts.
These rights consist of the following:
ReadAllows a user to view read-only copies of files
Check Out/Check InAllows the user to use the Check In and Check Out commands. These are used to store files and projects in the
database (check in), or retrieve them to make modifications (check out). Having this permission, however, doesnt enable the user to add,
rename, or delete files from a project thats been checked out.
Add/Rename/DeleteAllows the user to add, rename, delete, check in, and check out files. However, the user cannot destroy projects
and files.
DestroyAllows a user to use all commands associated with VSS. This gives the user the ability to permanently delete projects and files
from the VSS database. The users rights are equivalent to the default Read-Write access that is assigned to users before project security is
enabled and the default rights of users are modified.
By selecting or clearing these check boxes, you are defining the default rights of new users. Its also important to note that these rights are
progressive. For example, to have Check Out/Check In as a right, you also need Read. If you want to assign Add/Rename/Delete to a user,
then the previous two rights are automatically assigned as well. Finally, by assigning Destroy, you give the user each of the other previously
mentioned rights as well. Also, as well see next, these rights can be modified for users on a project-by-project or a user-by-user basis.
Once project security has been enabled, the Rights by project, Rights assignments for user, and Copy user rights commands become enabled
in the Tools menu. These allow you to control security by determining what rights a user has to specific projects or in general. As well see in
the paragraphs that follow, each of these commands allow you to control security in different ways.
New Page 6
Clicking Rights by project from the Tools menu brings up the dialog box shown in Figure 2-5. The left side of this dialog displays a tree of
projects that you can navigate through. Upon selecting a project, you can then select one of the user accounts associated with this database,
and assign user rights to each account. After selecting an account, click a check box beside a particular right to assign or remove that right. If
you would like to delete a user from having rights to a project, simply select the user, and then click the Delete user button. If you would like
to add a previously deleted user to the listing, you can click the Add user button.
Figure 5: Use the Rights by project dialog box to assign rights to user accounts for a selected project
The Rights assignments for user command is used to specify project rights to a VSS database. Upon selecting a user from the listing in the
VSS Administrator tool, you then click this command to bring up the dialog box shown in Figure 2-6. The top of this dialog has a section
called User rights, which lists each of the four rights weve discussed. Beside each right is a check box, which is used to add or remove rights
for that user from a project. Below this section is a listi of projects to which you can add or remove assignments. If youd like to add a project,
and specify the users rights to that project, you can click the Add assignments button. This will display a dialog box with a list of projects.
You can click a project in this tree, and then specify rights for that project by selecting the check boxes for rights on this dialog. Clicking OK
will add a selected project to the list of projects. Once added to the Assignments for user dialog, you can further modify the users rights by
selecting or clearing the check boxes of specific rights from this screen. Upon clicking OK, those rights are then assigned to the user.
Figure 6: Use the Assignments for user dialog box to assign rights and projects to a user
Select a user from the listing in VSS Administrator and then select the Copy user rights command to open a small dialog displaying a list of
users. Select a user from this list and click the Copy button, and the rights of that user are copied to the account that you selected before
clicking Copy user rights. This saves you the time of having to determine which group of rights a user should have. If you know that you want
to give a user called Darren the same rights as a user called Julie, you can copy Julies rights to Darrens account. Rather than having to
determine which rights to give and then select each right for the users account, you assign the rights in one easy action.
Its important to note that these rights can only be applied if an account has the default Read-Write rights. If youve selected Edit account
from the File menu, and then selected the Read only check box, only the Read right is assigned. This disables any additional rights that can be
given. The only right that can be effected through the commands in the Tools menu for this user would be the Read right. Although you can
remove or add the Read right on this users account, no other rights can be added.
The Lock SourceSafe database command in the Tools menu is used to lock users out of an open database. This is used when youre planning
to archive or back up the database, or upgrade or run certain executable programs, such as utilities. This command is only available to
administrators, and when used, it displays a dialog box showing which users are currently logged on to the database. By selecting the Lock all
users out of Visual SourceSafe check box and clicking OK, you keep any additional users from logging on and using that database. However,
the users who are currently logged on to the database are unaffected by this, and must be notified to log off.
New Page 6
The way the database is archived after Lock SourceSafe database has been selected is through the Archive projects command on the Archive
menu. When this is selected, the Archive Wizard appears, and the three-step process of archiving the database begins.
The first screen of the wizard has you select a project to archive. Upon clicking OK, you can either click the Add button to add additional
projects to archive, remove the project (by selecting it from the list and clicking Remove), or click Next to continue.
The second screen of the Archive Wizard is where you determine what you want to do with the selected projects. You have three options here:
Save data to file
Save data to file, then delete from database to save space
Delete data permanently
If you select either of the first two options, you need to specify where the data will be archived to, as well as a filename for that archive. The
last option purges the data from your database without saving it first.
The last screen of the wizard appears if youve chosen to save data to a file. Here, you can choose to either archive all of the data, or archive
the latest version in addition to older versions. If you choose the Archive this version and older option, a field becomes enabled in which you
specify a version. Any versions between this and the latest version will then be archived. If youd like to make a comment on what this
archive contains, you can enter it in the field below it. Clicking Finish closes the wizard, and archives the data.
The Archive Wizard is similar to the Restore Wizard, which is used to restore archived data to the VSS database. Selecting Restore projects
from the Archive menu starts this wizard. The first screen is where you specify which archive file you want to restore. Click Next, and you
will see a list of projects stored in the archive. You can select which files you want restored by either clicking a specific file in the tree, or by
clicking the Select all button. Just as the Select all button selects all files in the tree, Deselect all clears everything. When youve selected the
files to restore, clicking Next will bring you to the final step. Here, you choose whether to restore the files to the project they were archived
from, or to restore the files to a new location. If you choose the first option, it will overwrite existing files. Upon selecting one of these
options, clicking Finish will restore the files based on the criteria given through the wizard.
In addition to the previously mentioned commands in the Tools menu, there are also the following commands:
Clean up Temp DirectoryDeletes all temporary files in the VSS Temp directory
Create DatabaseAllows you to create new VSS databases
FontAllows you to choose a new font in which the VSS Admin tool should display information
Whereas the Font command is purely superficial, and the Clean up temp directory command is used for maintenance, the Create database
command is particularly important if you wish to create other databases that developers can save to. When this menu item is selected, a dialog
box appears that allows you to enter a location for the new database. You can select the check box on this dialog to indicate that all users of
this database use version 6.0 client software. If they use previous versions of VSS client software, then this check box should be cleared.
Exercise 2-3 Creating and Maintaining a User List with VSS Administrator
1. From the Windows Start menu, select Programs, | Microsoft Visual Studio 6.0 | Microsoft Visual SourceSafe. Click the Visual
SourceSafe 6.0 Admin shortcut in this folder to start the VSS Administrator tool.
2. From the Users menu, click Open SourceSafe database. Select the Common database from the listing of available databases, then click
OK.
3. From the Tools menu, click Options. Select the Project security tab, then click Enable project security. This will enable the previously
disabled commands in the Tools menu.
4. From the Users menu, click Add user. This will display a dialog box. Enter the user name you wish to use, followed by a password.
Click OK to save this new account to the list.
5. From the list of users, select the Admin user, and then click the Rights assignments for user command from the Tools menu. Notice that
the Admin users rights cannot be changed.
6. From the list of users, select the Guest user. Click Edit user from the Files menu, and then click the Read only check box. Click OK.
Notice that the Guest user now has Read-Only access to this database now.
7. From the Tools menu, click Rights assignments for user. Notice when the dialog box appears that no additional rights can be assigned,
as the user has Read-Only access.
8. From the list of users, select the account you created in Step 4. Click Rights assignments for user. Click the check box for the Read right.
Notice that all subsequent rights are automatically removed.
9. Click each check box for the rights on this dialog, so that every check box is selected. This will give your account full rights to VSS
commands. Click Close.
Using Visual SourceSafe
As mentioned previously, when a source code control system has been installed, new menu items and dialog boxes will appear in Visual C++
6.0. A submenu called Source control will appear in the Project menu, and a new tab will appear in the Options dialog. Through these new
additions, you can interact with Visual SourceSafe.
Until you actually open or create a project in Visual C++ 6.0, the only menu item in the Source control submenu is the one called SourceSafe.
Clicking this menu item opens the Visual SourceSafe Explorer. This application is similar to Windows or NT Explorer, except that you use
the VSS Explorer to browse and work with projects and files saved to the VSS database. As well see, many of the commands found on the
Project menu are also available through the VSS Explorer.
When you open the VSS Explorer, you see an interface similar to that shown in Figure 2-7. The difference between what you see in your copy
of VSS Explorer and whats shown in Figure 2-7 will be that you currently have no projects saved to VSS. As such, most of the panes or
windows in this program will appear empty. Regardless, what you can see is that the Visual SourceSafe Explorers interface is made up of
New Page 6
several panes. The left pane lists projects currently stored in the database youre using. By clicking a project in this tree, the right pane
displays files contained within the selected project. Below this is the Results pane. This shows you the results of operations performed through
Visual SourceSafe. For example, lets say you tried to check out (i.e. retrieve) a project that you currently have checked out. When you
attempt this, the Results pane will inform you, for each file checked out, that a particular file is already checked out by you.
Figure 7: The Visual SourceSafe Explorer allows you to browse through projects saved to the VSS database
The File menu of Visual SourceSafe Explorer contains a number of commands that affect the database that is being used, the projects in that
database, and VSS Explorer itself. The commands in this menu consist of the following:
Open SourceSafe DatabaseEnables you to open a new VSS database
Add FilesDisplays a dialog box that enables you to browse your hard disk for files to add to a project that youve selected in the Project
pane. These files are added to the VSS database with the currently selected project.
Create ProjectAllows you to create a new project, to which you can add groups of files
DeleteDisplays a dialog box that enables you to specify projects and files to delete. When the check box entitled Destroy permanently is
selected, these items are permanently deleted, and cannot be retrieved again.
RenameAllows you to rename a project or filename
PropertiesDisplays the properties of a selected project or file
Set Working FolderAllows you to change the folder in which your project resides. When you edit or compile projects and files, this is
done in the working folder that the project was originally saved to. It is not done in the VSS database.
Create ShortcutAdds a shortcut to the currently selected project or file on your Windows desktop
LabelDisplays a dialog box that enables you to add a label to the currently selected project or file
MoveDisplays a dialog box that enables you to move a selected project or file to another project thats saved in the VSS database
ExitCloses VSS Explorer
The Edit menu contains fewer commands, all of which are related to selecting and editing files. The View file command displays a dialog box
that allows you to choose whether to view a SourceSafe copy of the file, or to check out the working copy of this file for editing. The Edit file
command displays the same dialog. However, whereas the first option is selected for View file, the second option of checking out the file for
editing is selected for Edit file. The Select command is used to select a specific file, whereas Select all selects all files in the File pane. Finally,
if you have one file selected, and wish to now select everything but the currently selected file, you can use the Inverse selection command.
The View menu is used for sorting and searching for files. The Sort submenu is used to specify how files in the File pane are to be sorted (for
example, by name, user, etc.). This results in the same action as if you clicked a column header in the File pane. The Search submenu contains
commands for finding and filtering whats displayed in the File pane. You can use this to view files by their checked out status, or find
specific files by doing a wildcard search. Finally, you can use Cancel search to cancel any search youve done, and Refresh file list to refresh
the display of information in the File pane.
New Page 6
The SourceSafe menu is where we begin to see menu commands that appear in the Source control submenu of Visual C++ 6.0s Project menu.
The commands common to both menus consist of the following:
Get Latest VersionUsed to retrieve the most current read-only version of a file from the VSS database to the working directory
Check OutUsed to place a working copy of a file in your working folder
Check InUsed to update the project or file thats been saved to the VSS database
Undo Check OutCancels any changes made to a file in your working folder, so that current changes arent saved to the VSS database
ShareUsed to share files from other projects with the one currently in use. (This command is called Share from SourceSafe under the
Source Control submenu.)
In addition to these commands, there are commands in the SourceSafe menu in VSS Explorer that dont appear in the Source Control
submenu in Visual C++6.0. By selecting a shared file, and then clicking the Branch menu item, you can branch a file in two directions. From
the point where the branch has been set, developers in each project can now modify the file without their work overlapping. Each project has a
copy of the shared file. In the Project pane of VSS Explorer, a line will appear between these two projects, showing that they are connected.
By selecting Merge branch from the SourceSafe menu, you can then merge the branched files together.
The Tools menu also contains a number of commands found in the Source Control submenu in Visual C++6.0. Show history is used to show
the history of a project or file. In Visual C++ 6.0, select a file you wish to view the history of, and then choose this command from the Source
Control submenu. This will show what, if any, changes have been made to the selected file or files. When used through VSS Explorer
however, you also have the option of viewing the history of files as well as entire projects. As Figure 2-8 shows, different dialog boxes appear
depending on whether youve chosen View history for a file or a project.
Figure 8: The History options dialog box for projects is slightly different from the dialog box for files
Many of the options are identical on the History options dialog box, whether youve chosen View history for a file or a project. Common to
each of these are the Include labels and Labels only check boxes. When Include labels is selected, the user-defined name that a developer has
labeled the project or file is shown. If you select the Labels only check box, then the files and the projects with labels are shown in the history.
The From, To, and User fields allow you to specify a range of versions to show, or those versions worked on by a specific user. You use the
From and To fields together to specify a range, based on the time, date, version, or label of files or projects. When entering dates, they can be
in the format of 08.09.65, 08-09-65, or 08/09/65, but not as September 08, 1965. Also, you cant search for file labels when viewing the
history of a project. Once youve selected the options you wish to use, you can then click OK to view the history of versions of a file.
If youve selected View history for a project, there are still two additional check boxes to consider before clicking OK. The Recursive
checkbox is used when you want to include subfolders and the files within those folders. This will allow you to view the history of each
subfolder and its contents when viewing history by project. The Include file histories check box is used to indicate whether you want to
include files when viewing the history of a project.
Once youve clicked OK, the History of project or the History of file dialog box will appear. The one that appears depends on whether youve
selected to view the history of a project, or selected a specific file before using View history. This dialog contains a list of various files, and by
double-clicking a file, you can display the history information on that file. You can also display the history by selecting a file and clicking
Details. By clicking the Next or Previous buttons in the History details dialog that appears, you can move up or down the listing of files in the
history display. You can also check out and share files, or print or save a report on the various items in the History of project or History of file
dialog box.
In addition to View history, the Show differences command in VSS Explorer and the Source Control submenu of Visual C++ 6.0 can be used
to view information. This command is used to view changes to a file. When selected, it will compare changes made in the working copy to
that of the copy in the VSS database. This allows you to view differences between different checked-in versions of a file. This command is
only used to view differences in copies. In addition, it cannot be used to compare two files in a working project, and is only used to compare a
file in the working folder to whats been saved in the master copy in the VSS database.
In addition to the commands weve discussed, there are several other menu items that appear in the Tools menu of VSS Explorer that dont
appear in the Source control submenu of the Project menu in Visual C++6.0. These include:
Find in FilesEnables you to enter part or all of a string used in a specific file or project. Clicking OK starts a search for that particular
line of code
Files ReportDisplays a dialog box that enables you to create a report on files and the people who have modified them
OptionsEnables you to change aspects of VSS Explorer
FontChanges the font used to display files and information through VSS Explorer
Customize ToolbarEnables you to change buttons on the toolbar
New Page 6
Change PasswordUsed to change your Visual SourceSafe password
Just as VSS Explorer has some commands that dont appear in Visual C++ 6.0, the reverse also applies. There are some menu items appearing
in the Source Control submenu, found in the Project menu of Visual C++ 6.0, which dont appear in VSS Explorer. These consist of the
following:
Add to Source ControlUsed to add a projects files to the source code control systems database
Remove from Source ControlRemoves a projects files from the source code control database
SourceSafe PropertiesDisplays a specific file or projects source code control properties
Refresh StatusUsed to update the status of a file in the source code control system
Multiple User/Multiple Location Development
With Visual SourceSafe, developers working from different locations on the network can work on individual files, and on files stored in
projects, in the VSS database. Multiple developers can work on individual files stored in the database, and there is no limitation on the number
of copies of that file that users can check out. If more than one user checks out the same file, then the first user gets a read-write copy, while
each additional user who checks out this file gets a read-only copy of the file.
If a project has been saved to the VSS database, the default behavior of Visual SourceSafe is that only one user at a time is allowed to check
out files stored within a project. This means that only one developer at a time can work on projects or files that have been saved to the VSS
database. However, you can change this setting so that more than one user has the ability to check out a particular project.
To do this, you need to open the VSS Admin tool. Once open, use the Open SourceSafe database menu item on the Tool menu, and select a
database you want to change. After doing this, select Options from the Tools menu. This brings up the Options dialog box, where you can
change settings for VSS. The General tab of Options contains a check box entitled Allow multiple check outs. When this is selected, more
than one user can check out a file.
Exam Watch: Until the Allow multiple check outs check box is selected, only one user at a time can check out a file from the VSS database.
Allow multiple check outs is found under the General tab of Options in the VSS Administrator.
When this has been set, and more than one user checks out a particular file, the first time a file is saved to the VSS database, it is updated.
After this, each time users check in a file, those subsequent changes are merged. This enables multiple users from multiple locations to work
on a single project, using source code control.
Generally, when more than one user is working on a single file, they are modifying different lines of code. There may be times, however,
when two users modify the same line of code. As VSS checks changes before merging them into a master file, it can detect when two or more
users have made such conflicting changes. When it does detect this, it refuses to allow the check in of that file. It then sends a message to the
user checking in the file that the conflicting line of code needs to be changed before the file can be checked in. The user can then change his or
her local copy of the file to resolve the problem.
Versioning of the Source Code
As we saw earlier in this chapter, you can view the history of different versions of files and projects that have been saved to the VSS database.
This allows us to see changes to files, as Visual SourceSafe maintains multiple versions of a file. This means that each time changes are made
to a file, a new version of the source code is stored in the VSS database.
The version control in Visual SourceSafe helps to ensure that only one person at a time is modifying a file. Unless Allow multiple check outs
has been selected, only one developer has the ability to check out and modify a file. As we saw in the previous section, when multiple check
outs are allowed, Visual SourceSafe still protects one version of source code from overwriting another.
In previous sections we also saw that you can view the history of a file or project, and track the different versions of code that have been
checked in. You can then retrieve these previous versions, should you wish to reuse code from older versions in your current project. From
this, the versioning of source code also gives you the ability to track which programs use certain object-orientated code, then reuse that code
in other projects.
The way that Visual SourceSafe tracks different versions of files and projects is with version numbers, labels, and date/time stamps. In
discussing each of these methods, well see that these methods are either internally maintained by Visual SourceSafe, or applied by the user.
Each method keeps VSS from accidentally overwriting one version of a file with another.
As mentioned, labels are user-defined strings that are applied to a project or file. They can contain up to 31 characters, and allow the user to
give files and projects meaningful names or comments. By using labels, you can provide version information for Visual SourceSafe to use.
For example, by giving the label 3.1, 2B or NOT2B, you indicate a version number that is different from other versions of a product. You can
even use sentences to indicated what a particular version represents or has achieved in the development process. For example, Bug Fix 3 or
Approved by Testing are both valid labels to use.
Date/Time stamps are applied to files, indicating when they were modified or the last time the file was checked into the VSS database. This
allows VSS to look at when changes were last made, or when a version was last saved to the database. By looking at this date and time
information, VSS can determine which versions came before and after one another.
The version numbers used by Visual SourceSafe are different from the version numbers applied to a project in Visual C++ 6.0. Unlike those
in Visual C++ 6.0, you have no control over what version number is applied to a file or project. These are controlled exclusively by the source
code control system. Each time a project or file is updated and saved to the VSS database, Visual SourceSafe automatically increments the
version number. This number is always a whole number, and is never decremented.
This is different from the version numbers applied to projects in Visual C++ 6.0. A project in Visual C++ 6.0 includes a resource file that
defines the version of a project. There is only one of these files in each project and it can be accessed by clicking the ResourceView in Visual
C++ 6.0, which displays resource files included in the project. As shown in Figure 2-9, ResourceView shows the resources associated with a
particular project. Each resource type is contained in its own subfolder, including that of Version. Within the Version resource type is a file
called VS_VERSION_INFO, and by clicking it, you can bring up the Version Information Editor.
New Page 6
Figure 9: Use ResourceView in Visual C++ 6.0 to display the resources for a project
As shown in Figure 2-10, the Version Information Editor displays a considerable amount of information on a project. This information is
added to the compiled program, and much of it is available to an applications user by viewing the programs properties. The FILEVERSION
string indicates the version of a file, whereas the PRODUCTVERSION string indicates the version of the project as a whole. You can change
the version of a product or file by respectively double-clicking either the PRODUCTVERSION or FILEVERSION strings, which are
displayed through the Version Information Editor.
Figure 10: The Version Information Editor displays important project information
The format of the version information in these strings is read from left to right. Each number indicates a level of change to the application,
with the leftmost number indicating a major change. Each number to the right of this first number denotes smaller changes. For example,
when Microsoft made major changes to Windows 3.1, it introduced Windows 95. Windows 95 was actually version 4.0. This means the
version would have changed from 3, 1, 0, 0 to 4, 0, 0, 0. When Windows 98 was released, the changes to the operating systems code were
less drastic, so it was version 4, 1, 0, 0. As patches and updates to the operating system were made, the numbers to the right of 4.1 were
incremented. This same type of versioning should be applied when setting version information on applications that you create.
MFC Wizards
MFC is an acronym for the Microsoft Foundation Class Library. Like the foundation that you build a house upon, MFC provides the
foundation for building a good application. It provides you with commonly used code for such things as dialog boxes, menus, basic
input/output, and many other things. Rather than having to focus on creating the same objects or programming the same functionality over and
over again, MFC supplies the common code so that all you need to focus on is programming the application-specific code. It provides you
with a framework on which you build your application.
One of the powerful elements of MFC is the set of wizards included in Visual C++ 6.0. These wizards take you step-by-step through the task
of creating executable applications, controls, classes, and so forth. These wizards include the following:
MFC AppWizardHelps you create executable and dynamic link library (DLL) programs
MFC ActiveX ControlWizardHelps you create ActiveX controls
Custom AppWizardUsed to create custom program types
ClassWizardHelps you create new classes, define message handlers, and perform other routine tasks
WizardBarA toolbar that provides you with access to elements associated with the ClassWizard
When used, these wizards provide you with the ability to be walked through the tasks of creating classes, controls, applications, and
performing other tasks. Rather than having to perform actions and write necessary source code, these wizards do the work for you. This leaves
you with only having to write code that specifically deals with the program youre creating.
The MFC AppWizard actually comes in two forms. One creates an executable program with the extension of .EXE, while the other is used to
New Page 6
create dynamic link libraries with the extension of .DLL. When either of these versions of the AppWizard are run, source code files and
resource files are created, based on classes in the MFC library.
The Custom AppWizard is a wizard used to create your own custom AppWizards. When this is used, you can create a wizard that creates
project types that you define. Other developers can then use the AppWizard that you create to walk them through the task of creating an
application.
MFC ActiveX ControlWizard is used to create the files necessary to build your very own ActiveX control. This wizard takes you through the
steps, allowing you to specify run-time licensing agreements, how many controls the project will have, how many Help files should be created
for the project, how it activates, and so on. Once you have completed the steps of this wizard, Visual C++ 6.0 generates all the files needed to
create your control based on the criteria youve provided.
Except for the ClassWizard and the WizardBar, you can start any of these wizards by starting a new project. By selecting New from the File
menu in Visual C++ 6.0, you are met with a tabbed dialog box. By clicking the Projects tab of this dialog, youll see a list of various project
types that can be created. In this list, youll see Custom AppWizard, MFC ActiveX ControlWizard, MFC AppWizard (.EXE), and MFC
AppWizard (.DLL). Youll also see a field in which you enter the name of your project. Once the project name has been entered, you
double-click any of these wizards, or select a particular wizard and then click OK. This starts the wizard that youve selected.
Unlike the previously mentioned wizards, the ClassWizard works with projects that you currently have open in Visual C++ 6.0. It works with
the current project to create new classes, define message handlers, gather data, and so forth. It can also be used to define the events, properties,
and methods of controls created with other wizards, such as the ActiveX ControlWizard.
The WizardBar works with the ClassWizard. Through this toolbar, you can access the functionality of the ClassWizard and the ClassView of
Visual C++ 6.0. Using the toolbar, you can navigate through classes, and perform actions that are accessed through the ClassWizard.
On the Job: Until you name your project, the OK button on the New project dialog box will be disabled. You must name your project before
you can start any of the wizards or project types listed. This often throws off some new users to Visual C++ 6.0, as they try double-clicking a
project type, only to find that nothing happens.
The ClassWizard and WizardBar are started from within Visual C++ 6.0. The ClassWizard is started through the View menu, by selecting the
ClassWizard menu item. By clicking on this command, the ClassWizard will automatically appear. Because the WizardBar is a toolbar, it is
accessed the same way that any other toolbar is accessed. By right-clicking an empty section of the toolbar, a listing of available toolbars
appears. Upon selecting WizardBar from this listing, it will appear in your toolbar.
Once youve started a wizard, you then follow each of the steps, screen-by-screen until you reach the end. How many steps you go through
depends on the wizard being used, and the options selected on various screens of the wizard. Also, you dont have to complete all of the steps
in the wizard prior to clicking Finish. As soon as the wizard has gathered the required information, the Finish button becomes active, and the
developer can complete the wizard without visiting each of the steps. You then click Finish and the files required for your project are created.
Resource Editors
A resource editor is an interface that allows you to view and modify information contained in resource files of your project. They can be used
to create new resources, and modify or delete existing ones. Resource editors in Visual C++ 6.0 include the following:
Accelerator Editor
Binary Editor
Dialog Editor
Graphics Editor
Toolbar Editor
Menu Editor
String Editor
Version Information Editor
Earlier in this chapter we discussed one such resource editor, the Version Information Editor. Basically, each of the editors appear the same.
They provide information on a specific resource, and allow data to be modified by double-clicking an entry listed in the editor.
As we saw when discussing the Version Information Editor, you can start a resource editor by clicking the ResourceView in Visual C++ 6.0.
You then open the subfolder of a resource that you wish to view, and double-click a file contained within that subfolder. Upon doing so, the
related resource editor automatically opens. You can also create new resources and automatically go to the associated resource editor by
selecting Resource from the Insert menu, and then choosing the type of resource to insert into your project.
The Accelerator Editor is used to view and modify accelerator key assignments in your project. Accelerator keys are also known as shortcut
keys, and allow users to quickly access a command in your application by pressing a combination of keys. For example, ctrl-z is a common
shortcut key in Windows applications, and is used to undo a previous action. When you start a new project, such common accelerator keys are
automatically added. You shouldnt change predefined keys, as they are standard keys common to all Windows applications. To add a new
key, or change keys youve previously created, you begin by opening the Accelerator Editor, and then double-clicking the key you want to
modify. This brings up the Accel properties dialog box. Through this dialog, you can choose the keys used to invoke an action. You can
choose to use ctrl, alt, shift, or a combination of these, which are used in conjunction with a character that you select. You can also specify
whether an ASCII or virtual key identifier is used. A virtual key identifier is an identifier thats selected from the drop-down list on this dialog
box. By clicking the Next key typed button, you can simply press a key on your keyboard, and it is assigned as an accelerator key.
The Binary Editor allows you to view and edit resources at a binary level. To open this editor, you right-click a resource in ResourceView,
and then select Open binary data from the menu that appears. Upon doing this, the editor will open, and you can then edit the resource using
binary or hexadecimal format. Obviously, to do this, you will need an understanding of these formats, which is beyond the scope of this book.
The Dialog Editor is used to create and edit dialog boxes. Upon opening this editor, you will see a dialog box and a toolbar of various controls
that can be added to it. This enables you to view, add, and remove controls and code from an existing or new dialog box.
The Graphics Editor is used to view, draw, and modify images in various formats. This editor includes a number of tools, which are similar to
those included in the Paint program that comes with Microsoft Windows. Using this tool, you can create custom images to use in your
New Page 6
application. This editor allows you to create and modify icons and cursors used in your applications.
The Toolbar Editor is similar to the Graphics Editor. It too contains graphic tools, which allow you to create and edit images used on toolbars.
In doing so, the Toolbar Editor enables you to create, edit, and move toolbar buttons, create new toolbars, and convert bitmapped images into
toolbar buttons.
The Menu Editor is used to view, add, and modify menus included in your project. When this is started, it shows a menu system. You can
click the various menus on this system to expand them. In doing so, youll notice there are blank boxes appearing beneath menu items and in
the menu itself. By clicking these boxes, you can enter captions for new menu items. When entering a caption, you can type an ampersand (&)
in front of a letter in the caption to define an access or mnemonic key. This allows the user to press the alt key with the character following the
ampersand to access that particular menu item. For example, pressing alt and the f key would open a File menu. When it appears to the
end-user, the mnemonic key appears underlined on the menu. This allows the user to see what combination of keys (for example, alt and the
underlined key) should be used to access a top-level menu item. Once accessed, the end user can then navigate through the menu to access
items and submenus under that menu item.
When you add a new menu item, or double-click an existing one, a small dialog appears with two tabs. The Extended styles tab allows you to
select a check box indicating that the item should be ordered and aligned from right-to-left. This feature is usually for internationalization,
where languages read from right-to-left are to be supported. The General tab is the more commonly used tab, and contains considerably more
options, which are as follows:
IDUsed to specify a symbol thats defined in a header file
CaptionText that appears on the menu
SeparatorCheck box indicating that the menu item is a separator, which is a line used to separate different items on a menu
CheckedCheck box used to specify that the menu item is to appear checked
PopupCheck box used to indicate that the menu item is a pop-up menu
GrayedCheck box used to indicate that the menu item is inactive and appears grayed out
InactiveCheck box used to determine that a menu item is inactive. This is always checked if the Grayed option is checked.
HelpCheck box indicating that the menu item should be rightmost on the menu. In Windows, Help menus are always rightmost on a
menu
BreakDrop-down list to which you can set one of three values: None, Column or Bar. Column places the menu item on a new line in
static menus, and in a new column in pop-up menus. Bar also separates columns, but does so with a vertical line. None indicates that there is
no break.
PromptField where you can enter a string. This will appear in the status bar of your application when this menu item is highlighted.
Together, these options are used to control the appearance and behavior of specific menus and menu items. Once youve completed creating
your menu system, you can then use the ClassWizard to attach code to specific menu items.
The String Editor is used to edit strings that are used in your applications. These are stored in a string table, which contains a list of all IDs,
values, and captions used in the application. The string table is a facility for storing such information, when you dont want it hard-coded in
the application. When you open the String Editor, the string table is loaded into it, allowing you to view, add, modify, and delete any strings
contained in this table. To add a new string, simply right-click the String Editor, and then enter the new string.
Using the Gallery
The Gallery is a folder on the hard disk where you installed Visual C++ 6.0 that contains source code. Basically, the Gallery is a storehouse of
reusable code. When you install Visual C++ 6.0, a folder is added to the location where you specified Common files should reside. By default,
this would be \Program Files\Microsoft Visual Studio\Common\MSDEV98\Gallery. Contained in this folder are two default folders. One is
called Visual C++ components, and the other is called Registered ActiveX controls. The contents of these folders are exactly what their names
state.
The way you access the Gallery from within Visual C++ 6.0 is through the Project menu. By selecting Add to project from this menu, and
then clicking Components and controls, a dialog box opens, showing the contents of the Gallery. When the dialog box appears, you can enter
either of these two default folders and select components and controls to add to your project. Upon selecting a control or component, you then
click the Insert button on the dialog box to have that item added to your project.
Because the Gallery is a folder on your hard disk, you can use Windows Explorer to add additional folders to the Gallery folder. You can also
use it to copy additional components, controls, and source code to the Gallery for future use. Using Visual C++ 6.0, you can also use the Save
As command on the File menu to save source code files, components, controls, and so forth to the Gallery folder. Other developers with
access to this folder can then reuse your code in their own projects.
Subfolders are added to the Gallery when you use the Add components and controls option in Visual C++ 6.0. In using this command, you
can select components and controls that will be used in projects. After you add a new component or control, subfolders containing these
components or controls are created in the Gallery, keeping them available for other developers and future use.
Information Resources
At times, you may require information resources that can assist you with using Visual SourceSafe or developing with Visual C++ 6.0.
Fortunately, Microsoft provides a variety of ways to assist you. Some of these are available through Visual Studio and Visual C++ 6.0,
whereas others require additional software, a subscription, or a purchase.
Each product discussed so far includes a Help menu, which is used to access files containing reference materials. This may consist of tutorials,
examples, or other pieces of information. By using the Help menu, you can search online user assistance for specific areas youd like further
information on, or areas that you need assistance with.
MSDN is the Microsoft Developer Network, and as we saw in the previous chapter, serves as a comprehensive source of information. It
includes a knowledge base of information, product and software development kit (SDK) documentation, technical documents, examples,
sample code, and more. Although MSDN does come with versions of Visual C++ and Visual Studio, you may also be interested in obtaining
New Page 6
newer editions. MSDN is published every three months or so, and is available through subscription. This allows you to get the most current
information available delivered to your door.
TechNet is a technical reference source that is available through paid subscription from Microsoft. Each month or so you receive a set of
CD-ROMs that contain updates, technical papers, a knowledge base, and other information. You can subscribe to TechNet through the Web
site mentioned later.
In addition to these information resources, there are also a number of Web sites available that provide information on Visual C++ 6.0 and
other products available with Visual Studio. In using information on the Internet, remember that some information may not be reliable. After
all, any kid with a Web page editor and Internet access can slap a page on the Internet. As such, its best to stick with sites that have proven
that they have accurate information.
Microsofts Web site has a number of areas that deal with topics covered in this book. Some of these include:
Visual Studio Web site, http://msdn.microsoft.com/vstudio/
Visual C++ 6.0 Web site, http://msdn.microsoft.com/visualc/
Visual SourceSafe Web site, http://msdn.microsoft.com/ssafe/
MSDN Online, http://msdn.microsoft.com
TechNet, http://technet.microsoft.com
Each of these Microsoft sites contain up-to-date information, updates, and more on various Visual Studio products, inclusive to Microsoft
Visual C++ 6.0. To use any of these sites, youll need a modem (or network access to the Internet), Internet access, and a browser that is set to
accept cookies.
From the Classroom
Explore the Research Options in the MSDN Universe
For a developer and trainer, one of the most crucial factors for success is the ability to locate and digest information. Whether locating an
answer to a student's question, or understanding how to correctly utilize a class in the MFC Library, MSDN Library is one of the first resource
to turn to. There are several other features and options available with the Microsoft Developer's Network that merit further attention and
explanation.
MSDN Library can be installed on the developer's machine along with Visual Studio. However, there are other features of MSDN that can be
very useful. Similar to the MSDN Library, MSDN Online is an Internet gateway to all kinds of up-to-date product news, specifications,
upcoming events and product releases, training, and much more. The on-line version of the MSDN Library also contains product
documentation, sample applications, and sample code. MSDN Online Memberships are free and allow developers the ability to interact with
other Microsoft professionals using Online Special-Interest Groups (OSIGs) and the Members Helping Members program. MSDN Online
members are also able to download free trials and beta products.
MSDN Subscriptions are another useful service. With an MSDN Subscription, a developer will receive the latest updates to technical
information and product releases. MSDN Subscriptions are an annual membership product and come in three levels. The MSDN Library
Subscription is the basic subscription, providing sample code, access to current knowledge base articles and bug lists, specifications, product
documentations, books and periodicals, and conference and seminar papers. The MSDN Library Subscription also integrates with the Internet
so the user can navigate smoothly between the subscription-provided information and the information on MSDN Online. The second level is
the MSDN Professional Subscription. The Professional level includes all of the services of the Library Subscription as well as the latest
releases and pre-releases of the Windows operating systems, all of the available Software Development Kits (SDKs) and Device Driver Kits
(DDKs), International versions of Windows operating systems, and automatic updates are delivered when new releases or service packs are
available. The most comprehensive subscription available is the Universal Subscription. The Universal Subscription includes all of the
services available to the Professional and Library Subscription members, plus a full year of Microsoft's current and upcoming development
products, and the Microsoft BackOffice Test Platform.
Additional MSDN services include the MSDN Flash program, ISV Program, User Groups and Events. The MSDN Flash Program sends a
twice-monthly newsletter containing technical news, new or upcoming release information, and events. The MSDN ISV Program addresses
the needs of Independent Software Vendors that support or run on Microsoft Products. MSDN User Groups and developer events are available
to further facilitate the sharing of technical expertise.
When you are in the depths of Visual C++, swimming through Class members, Interfaces, and Compiler options, remember that you are not
alone. The Microsoft Developer's Network has a variety of resources available to assist you in finding solutions, and keeping up with the
fast-paced world of software development.
Now that weve discussed so much about Visual C++ 6.0 and its tools and wizards, lets look at a few scenario questions and their answers,
before taking on the test associated with this chapter. The questions are common ones that may not only help you with your exam, but also in
real world situations you may encounter.
What is source code control, and why is it important? Source code control enables you to track changes in
your programming code. This enables you to determine
changes that were made to the source code, when, and
by whom. This helps to organize the code, and enables
you to retrieve previous versions.
Why are two installations of Visual SourceSafe
available in Visual C++ 6.0?
There is a client and a server installation of VSS
available in Visual Studio. The client installation allows
developers to access a master source code control
database, whereas the server installation installs this
centralized database and administration tools.
New Page 6
I want more than one developer to be able to edit a
project file. How can I set VSS to allow multiple files to
be checked out?
On the General tab of Options in the Visual SourceSafe
Administrator tool, ensure that the Allow multiple check
outs check box is selected.
What are resource editors? Resource editors are interfaces used to view resources
included in a project. They allow you to view, add,
delete, and modify a number of different resources
associated with a project.
What is the purpose of the Gallery? The Gallery contains reusable components and controls
that can be added to your project. It also provides a
storehouse for source code that you want to reuse in
other projects.
Source code control refers to tracking changes in the program code that developers have written. This gives a development team or single
developer the ability to view such things as the history of source code, when changes took place, who modified the code, and so forth. If the
source code has been saved to a control systems database, then developers can restore old versions of source code. This protects their work
against bad modifications to source code, or corruption of the original files.
Visual SourceSafe is a source code control system that conforms to the Microsoft Source Code Control Interface. As such, once installed, you
can interact with Visual SourceSafe through Visual C++ 6.0, or through the tools included with VSS. Visual SourceSafe Administrator is used
to administer VSS databases and users who will use these databases. Visual SourceSafe Explorer allows you to work with projects through an
interface similar to that of Windows Explorer. Together, they provide a powerful system of controlling source code.
Visual C++ 6.0 comes with a number of wizards that aid you in creating new applications, controls, classes, and so forth. In using the wizards,
you follow the instructions on each screen. By the end of these steps, Visual C++ 6.0 generates the source code files that you need to add
application-specific code.
Resource editors are interfaces that allow you to view and modify information contained in resource files of your project. They are similar in
appearance, making all of them easy to use once one of them is mastered. By using these editors, you can create new resources, and modify or
delete existing ones.
The Gallery is a folder thats installed when you install Visual C++ 6.0 on your system. It contains two folders when installed: Visual C++
components and Registered ActiveX controls. These folders respectively contain prepackaged components and ActiveX controls, which can
be inserted into your projects. You can also add source code, controls, and components of your own making to the Gallery. This enables you
to reuse code that youve written.
There are a number of information resources available from Microsoft. This includes online user assistance, resource kits, MSDN, TechNet,
and Web sites. Such sources of information may include technical papers, updates, a knowledge base of information, sample code, product
and SDK documentation, technical documents, examples, and so on.
Two-Minute Drill
The Gallery contains prepackaged components and registered ActiveX controls that can be added to your projects. A project is a
collection of files that make up your application.
Source code is the programming code you write, which makes your program actually do things (that is, make calculations, open and
close files, display data, and various other operations).
Tracking changes to source code during software development enables you to see what work has been done and who has done it.
Tracking changes helps you analyze how those changes have affected the project as a whole.
The Microsoft Source Code Control Interface provides a method for source code control systems such as Visual SourceSafe to integrate
with the Visual C++ environment.
The commands associated with source code control dont appear until a source code control system is installed.
The menu items and the Options dialog box in Visual C++ 6.0 dont provide complete control over the source code control system.
Visual SourceSafe (VSS) is a source code control system, which allows developers to save copies of their source code to a database.
When a file is added to VSS, that file is stored in the VSS database.
The first step toward using Visual SourceSafe 6.0 is installing it. The Visual Studio installation CD-ROM comes with two setup options
for VSS: Visual SourceSafe Client installation, and Visual SourceSafe Server installation.
The client installation can be installed at the same time you install Visual C++ 6.0.
The Visual SourceSafe server installation is used to install a source code control database that stores versions of source code. It also
installs an administration application that will enable you to control who can access the source code files stored in the database and control
who can perform administration tasks.
Its important that you understand what resides in each of the folders created by VSS during installation. This will allow you to quickly
find applications and files needed when administrating VSS.
Remember that of the folders created in client and server installations of VSS, the \Win32 and \Setup folders are common to each. The
\Win32 directory contains tools needed to use VSS effectively, while \Setup is used for installing additional components or removing VSS
from a system.
After Visual Studio has been installed, you can still perform a Visual SourceSafe Client installation by using the Visual Studio
Installation Wizard. In doing so, Visual C++ 6.0 and other development systems previously installed through Visual Studio will become
integrated with the source code control system.
After Visual C++ 6.0 has been installed onto a computer, you can also add and remove different Visual Studio products with the
Add/Remove Programs applet found in the Windows Control Panel.
Although installing the Visual SourceSafe Client from a CD-ROM is effective, it is not the only way of performing an installation. There
New Page 6
is also the NetSetup method of installing the client portion. This is generally the recommended method of installing the VSS Client software,
as it allows users to install NetSetup over the network themselves.
Since NetSetup is the recommended method of installing Visual SourceSafe Client software, you should be especially familiar with this
client installation type. Key points to remember are that NetSetup only installs the client portion, its run from the folder containing VSS
Server, no installation CD-ROM is required, and that users themselves can install VSS Client without administrator assistance. However,
because it uses the installation files in VSS Server, and NetSetup is installed with VSS Server, this means that you must first install VSS
Server before you can run NetSetup.
Once youve installed Visual SourceSafe, you will still need to configure it, and create a list of users who will be able to use the source
code control system. This is done through the Admin program, which is formally called Visual SourceSafe Administrator.
Until you actually open or create a project in Visual C++ 6.0, the only menu item in the Source control submenu is the one called
SourceSafe. Clicking this menu item opens the Visual SourceSafe Explorer. This application is similar to Windows or NT Explorer, except
that you use the VSS Explorer to browse and work with projects and files saved to the VSS database.
The SourceSafe menu is where we begin to see menu commands that appear in the Source control submenu of Visual C++ 6.0s Project
menu.
Until the Allow multiple check outs check box is selected, only one user at a time can check out a file from the VSS database. Allow
multiple check outs is found under the General tab of Options in the VSS Administrator.
The version control in Visual SourceSafe helps to ensure that only one person at a time is modifying a file. Unless Allow multiple check
outs has been selected, only one developer has the ability to check out and modify a file.
The way that Visual SourceSafe tracks different versions of files and projects is with version numbers, labels, and date/time stamps.
MFC is an acronym for the Microsoft Foundation Class Library. MFC provides the foundation for building a good application. It
provides you with commonly used code for such things as dialog boxes, menus, basic input/output, and many other things.
The MFC AppWizard comes in two forms. One creates an executable program with the extension of .EXE, while the other is used to
create dynamic link libraries with the extension of .DLL.
Until you name your project, the OK button on the New project dialog box will be disabled. You must name your project before you can
start any of the wizards or project types listed.
A resource editor is an interface that allows you to view and modify information contained in resource files of your project. They can be
used to create new resources, and modify or delete existing ones.
The Gallery is a folder on the hard disk where you installed Visual C++ 6.0 that contains source code. Basically, the Gallery is a
storehouse of reusable code.
You can use Windows Explorer to add additional folders to the Gallery folder. You can also use it to copy additional components,
controls, and source code to the Gallery for future use. Using Visual C++ 6.0, you can also use the Save As command on the File menu to
save source code files, components, controls, and so forth to the Gallery folder.
MSDN is the Microsoft Developer Network, and serves as a comprehensive source of information. It includes a knowledge base of
information, product and software development kit (SDK) documentation, technical documents, examples, sample code, and more.
TechNet is a technical reference source that is available through paid subscription from Microsoft.
New Page 6

Chapter 3: The Physical Design
Documents. 4
Views. 4
Document Templates. 5
Frame Windows. 5
Thread Objects. 5
Application Object 5
Developing an MFC Application for Microsoft Windows 95/98/NT. 7
Using the MFC Framework. 10
Using Platform SDK for an MFC Application. 10
MFC Regular DLL. 12
MFC Extension DLL. 12
SDI 14
MDI 16
Non-Document/View Architecture. 17
Components. 19
Drawing. 19
Colors. 20
Text Drawing. 21
Mapping. 22
Priorities. 27
Synchronization. 28
Incorporating a Database into the Application. 30
Types of Libraries. 30
Types of Objects. 31
Properties. 35
Methods. 36
Events. 37
Two-Minute Drill 39
Answers to Exercise 3-3. 42
Elements of an Application Based on the MFC Framework
Platform SDK
DLLs
Routing Command Messages between a User Interface Object and a Handler Function
Document/View Architecture
MFC Drawing Architecture
MFC Printing and Print Preview Architecture
MFC Architecture and Multithreading
Accessing a Database
Properties, Methods, and Events of Components
Prior to the introduction of the Microsoft Foundation Class (MFC) Library, all Windows-based applications were created using the
Windows Application Programming Interface (API), (Win16 API). The Windows API is a set of functions and data structures written in
C that was used to interact with the Windows operating system. Programming application in Windows API was extremely complex. The
easiest tasks required several hundred lines of code. With MFC, the same tasks can be written in a few lines.
Since the introduction of the Microsoft Foundation Class (MFC) Library, developers have learned that using MFC will makes
Windows-based application development much easier. MFC functions as a thin layer over the Win32 API so developers can access the
Windows API with easy to use objects instead of calling the complex API functions. In order to be successful in Windows-based
programming with Visual C++, you must be familiar with every aspect of MFC, including the physical design, which we would talk
about in this chapter.
Elements of an Application Based on the MFC Framework
MFC is a set of prebuilt C++ components that are interfaces to Microsoft Windows. These reusable components encapsulate all the
common functions so that developers do not have to redevelop them every time. By using MFC, developers can greatly speed up their
development time. Another benefit of using MFC is that its included optional architecture simplifies development. Developers will have
a common location to add application-specific code in their application. Regardless of how an application is designed and structured, all
MFC applications have the same common elements: the documents, the views, the frame windows, the document templates, the
application object, and the thread objects. Please note that architecture included in MFC, such as the document/view architecture, does
not have to be used.
On The Job: Try to use MFC as much as possible. It greatly simplifies the coding process.
Documents
The document, specified by the document class, manages your applications data. The document is derived from the CDocument class.
The document object provides functions that other objects can use to access the data. The important functions within the document
object are as follows:
GetFirstViewPositionReturns the position of the first view to allow GetNextView to enumerate the views of the document
GetNextViewReturns a CView pointer to the next view in the view list of this document object
GetPathNameReturns path and filename of the document
GetTitleReturns the documents title
IsModifiedReturns nonzero if document has unsaved data and zero if it doesnt
SetModifiedFlagCan set or reset documents modified flag.
UpdateAllViewsUpdates all the views associated with this document
Views
The view object determines how the user sees and interacts with the documents data. MFC allows you to open multiple views of the
same data with a multiple-document interface (MDI) application, which we will talk about later in this chapter. An easy way to think of
a view is that the view is just a specific representation of the document. Each document can have multiple views.
The view object is derived from the view class. The view class shows the data on the document and it relies on the surrounding frame
windows for the basic windows functionalities, such as moving and resizing. The view class is derived from the CView class or a
CView-derived class and it handles the user interaction that affects the view.
Document Templates
The document template is in charge of linking your applications documents, views, and frame windows, which allows them to function
as one entity. You can create single-document or multiple-document templates, which the developer can use to create single-document
interface (SDI) and MDI applications.
Frame Windows
The frame windows host the applications view windows. The applications main frame window specifies the characteristics of the
frame windows that contain these views.
Thread Objects
A thread is the most basic unit of execution in a Windows-based application. If your application is multithreaded, you can create
multiple threads with the classes derived from CWinThread.
Application Object
The application object, derived from CWinApp, is the backbone of all MFC applications. It manages the start, the execution, and the
termination of an application by encapsulating the Win32 WinMain() function. The application object is also responsible for creating the
main frame window, which is where the user interfaces with the application. This object provides access to the following crucial
member functions of the CWinApp class function that dictate the execution of the application:
InitInstance()
Run()
OnIdle()
ExitInstance()
InitInstance() Member Function
The InitInstance() is the most important member function in the application object. This function initializes every instance of the
application that is executed. It is very common to override the InitInstance() member function in the classes of your application. Many
developers do it but are not required to do so.
Run() Member Function
The Run() function is responsible for sitting in a message loop waiting for and processing incoming messages. Once it receives
messages, it will send them to the main frame window of the application. When no messages are available to process, Run() will call the
OnIdle() member function to idle. When termination of the program is requested, the Run() member function will run the ExitInstance()
member function.
OnIdle() Member Function
The OnIdle() member function is used by the application object for idle processing. You are able to override the OnIdle() to perform
other background tasks. The default version updates the user interface element states.
ExitInstance() Member Function
The ExitInstance() member function is called when an instance of an application is terminated. This function is called by Run(), usually
when the user has requested that the instance of the application be closed. You usually would override the ExitInstance() member
function to clean up standard objects such as frame windows or views.
Developing an MFC Application for Microsoft Windows 95/98/NT
Windows 95, Windows 98, and Windows NT are Microsofts 32-bit operating systems. Because they all use the Win32 API and have
similar shells, most applications should work the same. However there are always some applications that developers find that work fine
on Windows 95/98, but encounter problems when running Windows NT. Some of these problems may be caused by not following the
proper API calling rules and conventions, misinterpreting the operating system platform, replacing system dynamic link libraries (DLLs)
with versions for the wrong platform, or simply bad coding.
However, not all malfunctioning applications are the fault of the developer. Windows 95/98 and Windows NT are different operating
systems. Windows NT enforces permissions and rights. Windows NT is also a Unicode operating system. In order for you to
successfully develop cross-platform Windows applications, you need to follow a few guidelines to minimize problems when developing
programs that are going to run on Windows 95/98 and Windows NT. Exercise 3-1 will show you a checklist so you will be able to
review the things to watch for when you develop on Windows 95/98/NT.
Versioning
Applications use either GetVersion or GetVersionEx to get the operating system platform, version, and build information. Some
applications encounter problems over their incorrect use of GetVersion. GetVersion returns two platform bits as well as the version
number. Because many applications only check for the operating system version number, and because Windows 95/98/NT all return 4 as
the version number, the application ends up calling Windows 95-specific calls to the Kernel32.dll. The same calls are not available on
Windows NT, so the Windows NT application ends up failing. Other times, applications only check for the two platform bits but will
end up misinterpreting the version of the operating system. In order for you to avoid these problems when using GetVersion, you should
get the two return bits as well as the version number or use GetVersionEx. GetVersionEx is the new version of GetVersion and is the
preferred method of acquiring version information from the operating system. GetVersionEx returns versioning information in an
OSVERSION structure that is less cryptic than the DWORD bits in GetVersion.
DLLs
Not all required DLLs exist on the users computer. An application should check to see if they are available. If they are not, it should be
prepared to install them. If the application detects an older version of a required DLL, users should be prompted to decide whether they
want to overwrite it or leave it as is. This is good practice because the user might not want his or her current version of the DLL to be
overwritten.
The application should check the operating system version. It is possible that the application will install a DLL from the incorrect
platform and this can cause many applications that access that DLL to function incorrectly. Applications must use refcount to maintain
the count on the DLLs that exist on the system. MFC and system DLLs should never be removed.
Security
Windows NT is a secure operating system and all applications that are being installed inherit the rights of the current user. Because the
application has the same rights as the user, some problems many arise when the current user does not have enough privileges for the
application to install critical files or write to the registry. To avoid problems like this, inform the user that he or she must have sufficient
privileges in order to install the application.
Exam Watch: The main difference between Windows 95/98 and Windows NT is security. Developers must keep this in mind when they
are designing programs that run on both platforms.
Large Drives
The creation of the FAT32 file system has caused some applications to display incorrect drive size information during installation with
drives larger than 2GB. The GetDiskFreeSpace API function, which returns the free space of the drive, caused many applications to fail
because it doesnt return the correct free space on a 2+ GB drive. If this is a big issue, you can use the updated API function
GetDiskFreeSpaceEx instead of the older GetDiskFreeSpace.
Hard-Coded Paths
API functions are available to start the operating systems executable files. Some developers choose to hard-code the path of the
executable rather than to use the API calls. Applications that have hard-coded paths can run into problems because executables are
stored in different paths on different operating systems. Sometimes the executables will change their implementation so that calling them
explicitly will not work.
Another problem with hard-coded paths is with the Registry. Keys are not necessarily in the same location on all platforms. In order to
ensure that your application will work in all platforms, substitute all hard-coded operating system executable calls and Registry keys
with API calls.
ANSI vs. Unicode
Because Windows NT is a Unicode operating system, all internal routines use Unicode character handling. Windows 95/98 uses
American National Standards Institute (ANSI) standards for internal routine character handling. In ensuring that an application is
Unicode-ready, it must be able to identify the operating system and use the ANSI or wide function calls (for Unicode) when necessary.
Exercise 3-1 Windows 95/98/NT Applications Development Differences Checklist
1. Ensure that you are retrieving the correct version of your Windows-based application by ensuring that you are returning the correct
variables, such as platform, build, and version with GetVersion and GetVersionEx.
2. Check to see if necessary DLLs are available.
3. If Windows NT is detected, be sure to tell users that when applications are installed they must have sufficient rights and privileges
to install the program.
4. The most accurate method to return the computers free space is to use GetDiskFreeSpaceEx.
5. Use API calls instead of hard-coding calls to an executable or to access keys within the Registry.
Platform SDK
Prior to MFC, the main way to write Windows-based applications was to do it with the Platform software development kit (SDK). By
using the SDK, you are essentially writing programs with the Win32 API. Though MFC makes Windows-based programming much
easier, it is not always the best way to create your applications.
Using the MFC Framework
MFC is more than a class library. The MFC is also an application framework that defines the structure of the application. The framework
encapsulates and handles many routine tasks for you. These abstractions are much more convenient and shield away many of the
nuances that Win32 API programmers face. An example of this is the document/view architecture. If the desired class or function is
available in MFC and it is sufficient, you should use the MFC framework.
Using Platform SDK for an MFC Application
With all the advantages surrounding using the MFC and its application framework, why would anybody want to use the Platform
software development kit (SDK), when its more difficult to use and it does not offer the abstractions that the MFC offers? MFC is a
C++ class library that is a wrapper around the Win32 API. The newest version, MFC 6.0, has about 200 classes available to it. Although
MFC could provide all of what you need, it also might not. Not everything available in the Win32 API is encapsulated in MFCone
example is the list control. Sometimes with extremely complex applications, you may need to mix your MFC application with some raw
Win32 API code. The only way to find out what you need is to gain some experience with MFC so that you understand its strengths and
weaknesses. Only then are you able to know when to use MFC by itself, or an MFC/Win32 API hybrid. Exercise 3-2 is a checklist that
allows you to review what you should have in mind when choosing between the Platform SDK and the MFC.
Exercise 3-2 Checklist for Choosing between the Platform SDK and the Application Framework
Company X is designing an MFC application. Here are the steps that a consultant will use to decide whether to choose the Platform SDK
or the MFC application framework.
1. If the functionality completely exists in MFC, then use MFC.
2. If the functionality is somewhat supported in MFC, then use MFC and the Platform SDK. Remember, MFC should always be your
primary choice to develop a Windows-based application as long as the functionality exists and is complete. If it does not, use as much of
MFC as possible and use the Platform SDK for the features that are not complete.
3. If the functionality is not supported in MFC, then use Platform SDK.
DLLs
Libraries are sets of compiled code that are included within an application at compile time. With DLL, or dynamic link libraries, the
libraries are linked at run-time, hence the name dynamic link libraries. DLLs are a lot more flexible, because you can update the libraries
without recompiling the entire application. AppWizard lets you create two types of DLLs that support the MFC library: MFC regular
DLLs and MFC extension DLLs. DLLs are similar to the static libraries that you encountered when you were dealing with C++. By
being able to link to the MFC library, your application is able to access the MFC methods and classes without having to duplicate the
object code within the API. With DLLs, code can be shared, which saves memory and space requirements.
MFC Regular DLL
An MFC regular DLL can use C++ classes, but it can only export C functions. If you need a DLL that can be loaded in any Win32
programming environment, you should use a regular DLL. With the MFC regular DLLs, you can choose to either dynamically or
statically link to the MFC library. With the statically linked library, a copy of the MFC library is included so that the DLL is
independently contained. With the dynamically linked library, the DLL is much smaller.
MFC Extension DLL
The MFC extension DLL can export entire MFC classes, MFC derived classes, C++ classes, member functions, and overloaded
functions. The client can create objects based on or derived from these classes and functions. The extension DLL can dynamically link to
the code in the MFC librarys DLL. Thus, the client program must be dynamically linked to the MFC library and the client program and
the extension DLL must be synchronized to the same version of the MFC DLLs. Because the client program is dynamically linked to the
MFC library, the DLLs are much smaller than regular, statically-linked DLLs. The MFC extension DLL can only be used with C++
compilers, such as Microsoft Visual C++ or Borland C++. Exercise 3-3 helps you to choose between the MFC extension and regular
DLL.
Exercise 3-3 Match the platform to the correct usage of the MFC Extension DLL and the MFC Regular DLL
Identify whether the platforms in the left column use the MFC extension DLL or the MFC regular DLL. (The answers to this exercise
appear just before the Self Test at the end of this chapter.)
Platform MFC extension or regular DLL?
Visual Basic
Visual C++
Visual J++
Borland C++
Symantec C++
Routing Command Messages between a User Interface Object and a Handler Function
Messages play a great role in Windows-based applications. Messages are created from a variety of actions, such as a mouse-click on a
menu item or by accelerator keystrokes. Command messages are messages that can be handled by many different objects, such as the
application, the documents, and the windows. Every object, which is capable of receiving command messages, has its own message map.
Each command message is identified by a constant that is assigned by a resource editor. When the object receives the command
message, it looks at its own message maps for a match. If it cant find the handler, it will route the command to the next object.
The handling order for SDI is as follows:
View
Document
Main Frame
Application
The handling order for MDI is as follows:
View
Document
Child Frame
Main Frame
Application
The application will go first to the class to which the message belongs. If it does not find a match, it will go down the list until it finds
the proper handlers. If there are multiple handlers, the handler at the higher level will be called.
Document/View Architecture
The document/view architecture is the core of the MFC application framework. In a document/view application, the data, also known as
the document, is managed separately from the application through which the users interact with the data. This allows the data to be
encapsulated by the way that the data is shown and the way that the user inputs it. The data and the code are separated. There are two
application types that have the document/view architecture: single-document interface and multiple-document interface.
SDI
The simplest application type that has the document/view architecture is the single-document interface (SDI). In an SDI application,
only one document is open at a time. An example of this is Notepad, as shown in Figure 3-1.
Figure 1: There can be only one document open at a time in an SDI application
Four classes make up SDI:
CWinApp
CFrameView
CDocument
CView
CwinApp creates all the applications components. Another main task is to receive all the event messages and to pass them to the
CFrameView and the CView.
CFrameView is the window frame that holds all the components that you see on the frame such as the toolbar, the menu, and the
scrollbar.
The CDocument class stores and manages your documents data, such as saving and retrieving information.
CView gets information from the CDocument class and it outputs the desired information for the user. This enables the user to interact
with the data that is managed by the Cdocument-derived class.
MDI
The multiple-document interface (MDI) is similar to the SDI application except that it allows the user to have multiple documents open
at the same time. Each document could consist of a different file, or of the same file but of a different view, such as a Microsoft Excel
spreadsheet and a pie chart based on the data from the Microsoft Excel spreadsheet, as shown in Figure 3-2.
Figure 2: MDI applications allow the user to have multiple documents open at the same time
Five classes make up an MDI application
CwinApp
CMDIFrameWnd
CMDIChildWnd
Cdocument
Cview
MDI contains all the same classes as an SDI application, except for the CframeView. Instead, the MDI has the CMDIFrameWnd and
CMDIChildWnd. The CMDIFrameWnd is the main frame of the application, where all interactions with the user take place. The
CMDIChildWnd class holds the CView class and it passes all messages and events to the Cview class. This class makes the access to
multiple documents possible, and this is where all the multi-document files are defined.
Non-Document/View Architecture
Although most of the applications that you will develop probably will use the document/view architecture, you can also develop
applications that do not use it. The document/architecture has many benefits, but the included disadvantages might make you decide not
to use it. For example, an application that does not show any documents does not need a main frame window or a view, such as the
Windows Sound Recorder shown in Figure 3-3.
Figure 3: The Sound Recorder is an example of a dialog-based application
A sample non-document/view architecture can contain the following:
An object based on the CWinApp class and a modal dialog box. This application is also called the dialog-based application
architecture. The dialog box will be the primary source for manipulating data.
An object based on the CWinApp object, a main frame (CFrameWnd) window, and a view. In this type of application, the view
will manipulate the data.
In the non-document/view application, you must override the CWinApp::InitInstance function to create the windows and the dialog
boxes. Exercise 3-4 will go over the things that you should remember when designing the interface of your application.
Exercise 3-4 Checklist for Using the Document/View Architecture
If your application does not need a main frame window or view, dont use the document/view architecture at all. Use a
dialog-based application.
If you need different views of your document or you need to have several documents open, use MDI.
If only one document needs to be open at a time, use SDI.
MFC Drawing Architecture
The drawing capabilities of MFC center on the Windows Graphical Device Interface (GDI). The GDI provides all the services needed to
draw in Windows. Prior to the GDI, programmers had to write program graphics to the video hardware and video standard.
Programming graphics was extremely frustrating because every new hardware device or standard had programmers scrambling to
support it. This all changed with the introduction of the GDI, which is a part of the hardware-independent graphics output model.
Programmers write to the GDI, and the GDI worries about interpreting the code to the hardware. This model frees up the programmer so
he or she can worry about graphics programming.
Whenever the Windows-based application needs to draw to a device, it accesses it through the device context. The device context (DC)
is a virtual desktop service that represents the device drawing surface. When you use MFC, you create a device context object and call
its member functions to do the drawing for you.
Components
The graphic components that MFC supports are as follows:
PensUsed to draw lines and curves
BrushesUsed to paint the interior of polygons and ellipses
PalettesSet of colors used by GDI to render an image
BitmapsGraphical image
FontsDefines the style of text being displayed
Drawing
The MFC CDC class encapsulates the device context, as well as the GDI function. The CDC functions for drawing lines, curves, and
closed figures are as follows:
MoveToSets the current position
LineToDraws a line from the current position to the defined position
PolylineConnects a set of defined points
PolylineToConnects a set of points from the current position to a set of defined points
ArcDraws an arc
ArcToDraws an arc and updates the current position to the end of the arc
PolyBezierDraws Bezier splines
PolyBezierToDraws Bezier splines and updates the current position to the end of the Bezier spline
PolyDrawDraws lines and Bezier splines and updates the current position to the last line or Bezier spline
ChordDraws a chord, an intersection of an ellipse and a line
EllipseDraws an ellipse
PieDraws a pie wedge
PolygonConnects a set of points to form a polygon
RectangleConnects a set of points to form a rectangle
RoundRectDraws a rectangle with rounded corners
Colors
You can set and manipulate colors by using the COLORREF value. COLORREF uses the red-green-blue (RGB) system, which uses the
intensity of three colors: red, green, and blue, to specify each color. To set the COLORREF value, you use the RGB macro. The RGB
macro takes three parameters: the intensities of red, green, and blue. You can set the colors with numbers in the range of 0 to 255. Table
3-1 shows the RGB values for the most common colors.
Color Red Value Green Value Blue Value
Black 0 0 0
Blue 0 0 255
Green 0 255 0
Cyan 0 255 255
Red 255 0 0
Magenta 255 0 255
Yellow 255 255 0
White 255 255 255
Dark gray 128 128 128
Light gray 192 192 192
Table 3-1: RGB Values for Common Colors
Text Drawing
Unlike drawing lines, to draw text you must first set the attributes to the text and then write it out to the device. The following is a list of
the main functions that control text-display attributes:
SetTextColor and GetTextColorThese control the color of the text displayed.
SetBkMode and GetBkModeThese functions control whether or not the cells that surround each letter are filled before the
corresponding characters are displayed. In Opaque mode, the cells are filled with the current background color. In Transparent mode, no
fill takes place.
SetBkColor and GetBkColorFunctions that control the color of the cells that contain the displayed text. The background mode
must be Opaque before this attribute is used in a fill.
SetTextAlign and GetTextAlignThese control the alignment of text relative to the window position specified in one of the
text-output functions.
The following is a list of functions that control text output:
TextOutDisplays a text string at the given location by using the currently selected font, colors, and alignment.
TabbedTextOutSimilar to TextOut, but supports expansion of tab stops.
DrawTextDisplays formatted text within a bounding rectangle.
ExtTextOutSimilar to TextOut, but allows specification of clipping options.
Mapping
In windows, the GDI translates logical coordinates to physical coordinates using the different mapping modes. You can set the mapping
modes with the SetMapMode device context function. By setting the different mapping modes, you control how the objects and the
coordinates are translated to the screen. Windows supports eight mapping modes.
MM_ISOTROPICLogical units are converted into random units with equally scaled axes.
MM_ANISOTROPICLogical units are converted into random units with random axes.
MM_HIENGLISHEach logical unit is converted to 0.001 inch. Positive X is on the right, positive Y is up.
MM_LOENGLISHEach logical unit is converted to 0.01 inch. Positive X is on the right, positive Y is up.
MM_HIMETRICEach logical unit is converted to 0.01 mm. Positive X is on the right, positive Y is up.
MM_LOMETRICEach logical unit is converted to 0.1 mm. Positive X is on the right, positive Y is up.
MM_TEXTEach logical unit is converted to 1 pixel. Positive X is on the right, positive Y is down.
MM_TWIPSEach logical unit is converted to 1/20 of a point. Positive X is on the right, positive Y is up.
MFC Printing and Print Preview Architecture
Like drawing, printing was a headache prior to Windows. The application had to be coded to deal with the many different print drivers.
With Windows, this process was streamlined in that the application printed to the GDI. To print without MFC, the application had to get
a device context to the printer and then call the StartDoc Win32 API function, which would start the print job. At every start in a page in
a document the StartPage function would be run. At every end in the page, the EndPage would run. This would loop until there were no
more pages to be printed. Then the EndDoc function would be called. This process is greatly simplified with MFC. With MFC, the
printer device context is automatically created and destroyed and the StartDoc, StartPage, EndPage, and EndDoc functions are called
automatically for you by using member functions in the Cview class. The necessary MFC functions that you should be familiar with are
as follows:
OnPreparePrintingThis is called prior to any printing or previewing.
DoPreparePrintingDisplays the Print dialog box and creates the printer device context. You set the maximum page count here.
OnBeginPrintingThis is called when the print job starts. You can overwrite this function to create resources that you need for
printing, such as fonts. You set the maximum page count here also.
OnPrepareDCThis is called before any drawing starts to prepare the device context. Override this function to modify the device
context, such as pagination.
OnDrawThis function displays the images you see in the print preview window as well as how it would appear on the printer.
OnPrintThe function that is called for printing or print preview. Override this function to provide additional printing features,
such as headers and footers.
OneEndPrintPreviewThis is called when print preview mode is exited.
OnEndPrintingThe function that is called when the print job is finished. You must override this function to release any resources
that you created.
Exam Watch: The most common print function to override is the OnPrint function. You must override this function to print more
standard features such as footers and headers.
Print preview is much different that printing. With print preview, the application simulates the printing of a document onto the screen.
This is done with the CDC derived class, CpreviewDC. When print preview is selected, the CpreviewDC object is created. You can
modify print preview so you can get a scrollbar, to maintain the users original position, and cause print preview to output specially
formatted page numbers. Exercise 3-5 will help you become more familiar with the print and print preview architecture in MFC.
Exercise 3-5 MFC Print and Print Preview Architecture
Based on the following scenarios, choose the MFC function that you need to override. (The answers to this exercise appear just before
the Self Test at the end of this chapter.)
1. You would like to have customized headers and footers.
2. You want to modify the device context.
3. You want to set the maximum page count.
4. After creating objects, you need to overload this function to release the resources created by your objects.
From the Classroom
MFC Printing Support
As discussed in this section, MFC adds printing support through member functions in the CView class. The most important of these
member functions are OnPreparePrinting, DoPreparePrinting, OnBeginPrinting, OnPrepareDC, OnDraw, OnPrint, OnEndPrintPreview,
and OnEndPrinting. With these functions you can perform all of the tasks necessary to include print and print preview capabilities in
your application. There are, however, a couple of other handy printing features built into the CView and CWnd classes that make
dealing with printers and print jobs very simple. Specifically, let's look at how to obtain information about the default printer, and how to
obtain information about the current print job.
There are two methods to find out default printer settings. You choose the method to use based on when the information needs to be
known by your application. If your application needs to know about the default printer on startup, you will need to override the
InitInstance member function of the application object derived from CWinApp. In InitInstance, call GetPrinterDeviceDefaults, which
gives you a reference to a PRINTDLG object, then call CreatePrinterDC, which gives you a reference to an object containing default
printer characteristics. This could be accomplished with code such as the following:
PRINTDLG pdialog;
GetPrinterDeviceDefaults(&pdialog);
CDC defaultCharacteristics;
if (CreatePrinterDC(dc) != 0)
{
//get default characteristics
}
If you need to get the default printer setting some time following application startup, or to monitor any changes made to the default
printer, you need to implement the OnWinIniChange member function of the main window class in your application. This method is a
member function of the CWnd class that provides the base functionality of all window classes in the Microsoft Foundation Class
Library.
You may also want to find out information about the printer's current print job. You can do this by using the pInfo parameter that is
passed to the CView member functions. The pInfo parameter of the CView:OnXxxx functions contains a pointer to an object named
CPrintInfo. Information about the print job is contained in the CPrintInfo object and accessed using its class members.
The MFC is a valuable tool for building Windows applications, and it has made one of the messiest tasks of application
developmentprintingseem almost trivial. We have only pointed out some of the major printing features in the MFC, but by no
means have we shown all of the printing support built into the Microsoft Foundation Classes. To find out more about these features, try
searching on the classes, objects, and member functions we have looked at in this section using MSDN, either on-line, through your
subscription, or on the MSDN CD provided with Microsoft Visual Studio.
MFC Architecture and Multithreading
MFC supports multitasking through its threading model. Thread-based multitasking allows users to run more than one instance of a
program as well as run different tasks in a single application. This is similar to running subapplications within a single application. An
example of this is running a spell checker while you are typing a document. A thread is the basic unit of execution. With thread-based
multitasking, the developer can fully control the way the application executes. MFC has two types of threads: the interface thread and
the worker thread. An interface thread can receive and process messages. A worker thread does not receive or process messages, it just
provides additional paths of execution for the main thread. The user interface can create windows and process messages sent to those
windows. MFC supports multithreading with the CWinThread. The main thread of an executable is always an interface thread. The main
thread can spawn additional worker threads that will facilitate multithreading. You create a worker thread with the function
AfxBeginThread. You terminate the thread with AfxEndThread. You suspend a thread, or pause the execution of a thread, with the
CWinThread::SuspendThread() function. You can resume a suspended thread with CWinThread::ResumeThread.
Priorities
Every process has a priority class assigned to it. The priority is used to help determine how much central processing unit (CPU) time that
the process has access to. Processes that are crucial have higher priority than lower priority ones. The different priority classes are
REALTIME_PRIORITY_CLASS
HIGH_PRIORITY_CLASS
NORMAL_PRIORITY_CLASS
IDLE_PRIORITY_CLASS
By default, programs are given the normal priority class. You need to be cautious with assigning the correct priority class. Assigning an
applications priority class to real time can hog the entire CPU and slow down or halt execution of other threads. High priority class is
set when you need priority higher than normal but the program is not crucial to the system. The default priority class is the normal
priority class. Set applications to the idle priority class when you need the application to run only when no other applications are waiting
for the CPU. You can set the priority with the function SetPriorityClass(). You can return the current priority with GetPriorityClass().
You can also set the priority of the individual threads within a process. You use GetThreadPriority() and SetThreadPriority to do this.
The different priority settings are
THREAD_PRIORITY_TIME_CRITICAL
THREAD_PRIORITY_TIME_HIGHEST
THREAD_PRIORITY_ABOVE_NORMAL
THREAD_PRIORITY_NORMAL
THREAD_PRIORITY_BELOW_NORMAL
THREAD_PRIORITY_LOWEST
THREAD_PRIORITY_IDLE
Synchronization
With multithreading, synchronization becomes a necessity when two or more threads need access to a shared resource that has a limit on
how many threads can access it. The prevention of one thread from accessing a resource that another thread currently is accessing is
called synchronization. The following classes encapsulate synchronization objects:
CCriticalSectionAllows only a section of code to be accessed at one time. This encapsulates the simplest type of thread object.
This is done with the CCriticalSection::Lock member function to lock the resource before it is used. CCriticalSection::Unlock unlocks
the resource after it is used.
CEventEvents can block a process from accessing a resource until another thread allows it. CEvent supports two types of events:
autoreset and manual reset. An autoreset event will automatically reset it itself after the resource is released. Manual reset forces the
developer to write code to release the resource. Autoreset events use SetEvent to trigger the event if it is one thread and they use
PulseEvent for two or more threads. ResetEvent is run automatically. With manual reset, the developer can check for the state of the
event with the m_hObject data member.
CMutexMutex is a combination of the words mutually and exclusive. It is used to gain exclusive access to a resource shared by
multiple threads, as well as to synchronize the threads running in the same process or in different processes. Like the CCriticalSection, it
uses the Lock and Unlock member functions to lock and free resources.
CSemaphoreA semaphore signals that a limited number of threads can access a resource. This is unlike the other synchronization
object classes. A semaphore uses a resource count to determine how many threads are accessing the resource simultaneously. Every time
the Lock member function is run, the resource count is incremented. When Unlock is run, the resource count is decremented. When the
count hits the resource maximum, Lock will lock the resource until the resource count goes below the threshold.
CSingleLockThis controls access to one synchronization object. You can use it to control a critical section, a mutex, an event, or a
semaphore.
CMultiLockControls access to multiple synchronization objects. This can control a critical section, a mutex, an event, or a
semaphore. The advantage of using CMultiLock is that it can block up to 64 synchronization objects at once, and it can block all of them
until one of them is free or until all of them are free.
Exercise 3-6 will help you choose the thread priority class when you are developing your application.
Exercise 3-6 Choosing the Thread Priority Class
Based on the following scenarios, choose the thread priority class that you should use. (The answers to this exercise appear just before
the Self Test at the end of this chapter.)
1. You want to do a background spell check.
2. You want to defragment your hard drive when the computer is idle.
3. You want to run a service critical to system operation.
4. You are creating a standard application.
Accessing a Database
As corporations depend more and more on databases, more applications are needed to access a database. Visual C++ provides many
technologies to allow access to databases in your applications. It supports Data Access Objects (DAO), Open Database Connectivity
(ODBC), OLE DB, and ActiveX Data Objects (ADO).
Incorporating a Database into the Application
In order for a database to be incorporated into the application, you will need to be able to access the database from your application.
Visual C++ contains all the components needed to create a database application. This can be done with the available libraries and
database objects included in Visual C++.
Types of Libraries
You can access database objects through libraries included in Visual C++, such as MFC, the Active Template Library (ATL), and the
Platform SDK.
MFC
In order to use the MFC library for databases, you must use ODBC or DAO. With the MFC library for ODBC, you can access any
database that has an ODBC driver. With MFC ODBC, you can use objects instead of using connection handles and statement handles.
MFC DAO is a set of Component Object Model (COM) interfaces. However, DAO only allows access to flat file databases, such as
Access. MFC DAO is the fastest way to access the flat file database.
ATL
The Active Template Library (ATL) is used to create lightweight controls based on COM. These controls are much smaller than MFC
and are extremely suitable for client/server applications. ATL is the way to develop applications if the functionality is to be used in
several applications. ATL will build controls that can be plugged into an application that will extend its functionality. However, ATL
can support OLE DB, which allows access to everything ODBC offers as well as access to other data sources, such as an Excel
spreadsheet. It must be noted that ATL does not support ODBC. Access to data must go through the OLE DB interface. Because OLE
DB is based on COM, data access is encapsulated and componentized. This is more efficient compared to traditional database access
because access is split into two components: the consumer and the producer. The consumer is the code that uses the OLE DB interface.
A provider exposes that interface. By splitting the access to the data, client-side resource overhead is much less. ATL provides templates
to make creating the two components much easier. For client/server applications, ATL is the ideal choice for accessing databases.
Platform SDK
Using the Platform SDK to access the database is the most powerful way to use databases, but also the most complex. You should use
the Platform SDK only if MFCs database classes and ATLs OLE DB are not sufficient to provide what you need.
Types of Objects
You access databases through different objects. There are pros and cons to each object.
ADO
Of all the different data objects available in Visual C++, ActiveX Data Objects (ADO) represents the future of database connectivity for
database developers. ADO is a wrapper around OLE DB, which was created to replace ODBC. Microsoft introduced OLE DB in an
effort to eliminate any bias to any data storage format. OLE DB allows a direct COM interface to the destination data source.
ODBC
Open Database Connectivity (ODBC) has been the most popular way for database developers to access any relational database. Its a
database interface standard that allows access with an ODBC driver. Though ODBC is currently very popular, Microsoft is pushing
developers to focus on ADO/OLE DB and wants it to be known that it is the proper way to access data stores.
RDO
Because using the ODBC API can be quite unwieldy, Microsoft introduced Remote Data Objects (RDO). RDO is a thin wrapper around
the ODBC API. RDO translates the manipulation of the data objects as well as their properties and methods and sends the appropriate
calls to the ODBC API. Because RDO has an object-type interface, it takes away a lot of the guesswork involved in connecting to an
ODBC data source. However RDO is not available in Visual C++. Exercise 3-7 will help you choose the correct database object and
library.
Exercise 3-7 Choosing Database Objects and Libraries
Based on the following scenarios, choose the database object or library that you should use. (The answers to this exercise appear just
before the Self Test at the end of this chapter.)
1. You want to do a client/server application. What library should you use?
2. You want to be able to access an Excel spreadsheet. What database object should you use?
3. You want to manipulate data in Access. What library should you use?
4. You are creating a standard database application. The database uses a standard ODBC driver. What database object should you
use?
From the Classroom
Unraveling the Variations in Microsoft Data Access Technologies
Almost all applications rely on the processing and maintenance of information, so one of the most important architectural decisions
made for an application is what method will be used to perform data access. Unfortunately, the various terms and acronyms associated
with using Microsoft technologies for data access are not always simple to remember or easy to keep straight. One topic I find myself
explaining over and over is defining the various data access methods and their associated acronyms. Since data access is such an
important topic, and there are so many terms floating around associated with Microsoft's data access technologies, let's go over them
again.
The first basic concept to understand is Open Database Connectivity (ODBC). ODBC is an international standard designed to allow
developers to access relational data using a similar syntax (SQL commands) regardless of the location and vendor of the database.
ODBC consists of two main pieces: ODBC Drivers and the ODBC Driver Manager. Drivers provide database management system
system-specific implementation of the ODBC interface specifications. The ODBC Driver Manager provides a means to set up and
manage connection settings for a driver to a specified data source.
The term DAO (Data Access Objects) is sometimes used to refer to all types of data access. It is important to remember the place of
Data Access Objects at the present time. DAO consists of a set of OLE automation classes that access data being stored in databases that
use the Microsoft Jet Database Engine, such as Access or FoxPro. The MFC DAO classes are easy to use and best suited for applications
that access desktop databases.
ActiveX Data Objects, or ADO, is the evolution of DAO. When using DAO, it is necessary to adhere strictly to the DAO object
hierarchy and create separate instances of the various classes in the hierarchy for each table or result set you need to access. ADO,
however, is much more flexible with fewer dependencies between the various objects in the ADO hierarchy. Another advantage ADO
has over DAO is that you are not limited to using it only with the Microsoft Jet Database Engine.
ADO accesses data from across an enterprise by providing a thin wrapper over OLE DB. Where as ADO is the evolution of DAO, OLE
DB can be thought of as the evolution of ODBC. Like ODBC, OLE DB provides access to multiple data sources, however, unlike
ODBC, OLE DB is not limited to only accessing relational data. An increasing number of OLE DB Providers are being made available,
and until all data sources can be accessed through OLE DB, there is an OLE DB Provider available for ODBC drivers.
OLE DB is the backbone of ADO, and Remote Data Service, or RDS, is an extension of ADO developed for client applications that
need to remotely use an ADO recordset using HTTP, HTTPS, or DCOM. RDS uses the Remote Data Object, RDO, on the client, and it
was mainly developed for use by VB and Internet developers. To use RDO in C++, it is necessary to embed the Remote Data Object in
your application.
Microsoft Data Access Components, or MDAC, encompass the four technologies of ADO, RDS, ODBC, and OLE DB, as well as the
Microsoft OLE DB Provider for ODBC. Another term used to refer to these data access technologies is Microsoft's Universal Data
Access. Read up on these technologies, and any new acronyms the data access developers come up with, on Microsoft's web site.
Knowing how each data access method works will help you pick the best access method for your application.
Properties, Methods, and Events of Components
ActiveX controls are software components that can be attached to different programs, providing additional functionality. ActiveX brings
this type of plug and play interoperability to windows applications. Software components allowed only certain parts of an application
to be upgraded or replaced. ActiveX components are based on newer OLE (Object Link Embedding) and use the Component Object
Model. COM defines how components can interact seamlessly between each other.
Properties
A main feature of ActiveX controls is their ability to expose their properties using a primary dispatch interface. Through this dispatch
interface, an ActiveX control container can access the control as a resource. The properties of the control expose the attributes of the
control container to the container. There are two types of properties: stock and custom.
The stock properties are properties already implemented in the ColeControl-based class and cannot be altered. This is the common
functionality of the ActiveX control. There are nine stock properties:
AppearanceSets the control as flat or 3-d
BackColorSets the controls background color
BorderStyleSets the controls border style
CaptionSets the controls title
EnabledDetermines if the control is enabled
FontSets the controls current font
ForeColorSets the controls foreground color
hWndSets the controls window objects handle
TextSets the controls title
Sometimes the stock properties do not provide enough functionality. You may wish to introduce custom properties. For a custom
property, you must provide the declaration and the implementation. There are four types of implementation for a custom property:
Member VariableImplementation in which the member variable is exposed to a container
Member Variable with NotificationImplementation in which the member variable is exposed to a container and the control is
notified when there is a change in the property
Get/Set MethodsImplementation that calls a method that gets the current property value and a method that sets the property value
ParameterizedSame as the Get/Set methods implementation except it allows access to a group of values through a single property
Methods
ActiveX methods allow the client to perform functions on the control. Like properties, the methods are implemented by the primary
dispatch interface. There are two types of methods: stock and custom.
Stock methods are methods already implemented by the ColeControl base class. There are two stock method implementations.
DoClickThis event is fired when the control is clicked.
RefreshThis event refreshes the control.
Custom methods are methods that you create. The COleControl class does not support custom methods. MFC implements custom
methods using the DISP_FUNCTION() macro. The macro, which refers to the handler function, must be declared in the control class
and implemented in the projects program file. You must also insert the id statement in the primary dispatch interface of the .ODL file.
Events
Events in ActiveX are a way for the ActiveX control to notify the container about the control. An event is usually activated by mouse
actions or keystroke actions. Like properties and methods, MFC supports two types of events: stock and custom.
The ColeControl base class implements stock events. They are the most common events for an ActiveX control. The stock events are
ClickFired when the control is clicked
DblClickFired when the control is double-clicked
ErrorFired when an error has occurred within the control
KeyDownFired when the key is pressed down
KeyPressFired when the key is pressed and released
KeyUpFired when the key is released
MouseDownFired when the mouse button is pressed
MouseMoveFired when the mouse cursor is moving within the control
MouseUpFired when the mouse button is pressed within the control
ReadyStateChangeFired when the state of the control changed
Custom events are events that are not supported by the ColeControl class. Custom events are implemented with the EVENT_CUSTOM
macro by MFC. The syntax is: EVENT_CUSTOM(ExtName, FiringFunc,Params)
ExtName is the external name of the event. FiringFunc is the control classs event firing function. Params is the list of parameter types
passed to the FiringFunc.
The macro, which refers to the handler function, must be declared in the control class and implemented in the projects program file.
You must also insert the id statement in the primary dispatch interface of the .ODL file. Exercise 3-8 will help you review components.
Exercise 3-8 Checklist for Evaluating Components
If it has to do with the appearance of the component, set the properties of the component.
If you need to run a type of macro, set the methods of the component.
If you need to notify the component based on an action, set the events of the component.
Since the introduction of the Microsoft Foundation Class (MFC) Library, developers have learned that using MFC makes
Windows-based application development much easier. MFC functions as a thin layer over the Win32 API so developers can access the
Windows application programming interface (API) with easy-to-use objects instead of calling the complex API functions.
MFC applications have the same common elements: -documents, -views, -frame windows,-document templates, -application objects,
and thread objects. When developing MFC applications, problems may arise in developing for the Windows 95/98/NT platform.
Problems are often caused by not following the proper API calling rules and conventions, misinterpreting the operating system platform,
replacing system DLLs with versions for the wrong platform, or simply bad coding.
Prior to MFC, the main way to write a Windows-based application was to do it with the Windows API and the Platform SDK, (Platform
software development kit). By using the SDK, you are essentially writing programs with the Win32 API. Although MFC makes
Windows-based programming much easier, it is not always the best way to create your applications.
Libraries allow you to share code in different applications. DLLs are dynamically linked at run time. There are two different types of
DLLs supported in MFC: MFC regular DLL and MFC extension DLL. MFC regular DLL can use C++ classes. However, unlike the
MFC extension DLL, the MFC regular DLL can only export C functions.
The drawing and printing capabilities of Windows center on the Windows GDI in MFC. MFC supports multitasking through its
threading model. Thread-based multitasking allows users to run more than one instance of a program and to run different tasks in a
single application.
Visual C++ provides many technologies to allow access to databases in your applications. It supports Data Access Objects (DAO),
ODBC, OLE DB, and ActiveX Data Objects (ADO). In addition to databases, components such as ActiveX controls can be created
allowing database functionality to be componentized. ActiveX brings this type of plug and play interoperability to Windows-based
applications.
Two-Minute Drill
MFC functions as a thin layer over the Win32 API so developers can access the Windows API with easy-to-use objects instead of
calling the complex API functions.
Regardless of how an application is designed and structured, all MFC applications have the same common elements: the
documents, the views, the frame windows, the document templates, the application object, and the thread objects.
The document is derived from the CDocument class. The document object provides functions that other objects can use to access
the data.
MFC allows you to open multiple views of the same data with a multiple-document interface (MDI) application.
An easy way to think about views is that the view is just a specific representation of the document. Each document can have
multiple views.
You can create single-document or multiple-document templates, which cam be used to create single-document interface (SDI) and
MDI applications.
The frame windows host the applications view windows. The applications main frame window specifies the characteristics of the
frame windows that contain these views.
A thread is the most basic unit of execution in a Windows-based application. If your application is multithreaded, you can create
multiple threads with the classes derived from CWinThread.
The application object, derived from CWinApp, is the backbone of all MFC applications. It manages the start, the execution, and
the termination of an application by encapsulating the Win32 WinMain() function.
In order for you to successfully develop cross-platform Windows-based applications, you need to follow a few guidelines to
minimize problems when developing programs that are going to run on Windows 95/98 and Windows NT. These guidelines cover
versioning, DLLs, security, drive size, hard-coded paths, and ANSI versus Unicode.
The main difference between Windows 95/98 and Windows NT is security. Developers must keep this in mind when they are
designing programs that run on both platforms.
MFC is a C++ class library that is a wrapper around the Win32 API. The newest version, MFC 6.0, has about 200 classes available
to it.
MFC is more than a class library. The MFC is also an application framework that defines the structure of the application.
Libraries are sets of compiled code that are included within an application at compile time. With DLL, or dynamic link libraries,
the libraries are linked at run-time, hence the name dynamic link libraries.
An MFC regular DLL can use C++ classes, but it can only export C functions. If you need a DLL that can be loaded in any Win32
programming environment, you should use a regular DLL.
The MFC extension DLL can export entire MFC classes, MFC derived classes, C++ classes, member functions, and overloaded
functions.
Command messages are messages that can be handled by many different objects, such as the application, the documents, and the
windows.
In a document/view application, the data, also known as the document, is managed separately from the application through which
the users interact with the data.
The simplest application type that has the document/view architecture is the single-document interface (SDI). In an SDI
application, only one document is open at a time.
The multiple-document interface (MDI) is similar to the SDI application except that it allows the user to have multiple documents
open at the same time.
In the non-document/view application, you must override the CWinApp::InitInstance function to create the windows and the dialog
boxes.
Whenever the Windows-based application needs to draw to a device, it accesses it through the device context. The device context
(DC) is a virtual desktop service that represents the device drawing surface.
You can set and manipulate colors by using the COLORREF value. COLORREF uses the red-green-blue (RGB) system.
Unlike drawing lines, to draw text you must first set the attributes to the text and then write it out to the device.
In windows, the GDI translates logical coordinates to physical coordinates using the different mapping modes. You can set the
mapping modes with the SetMapMode device context function.
With MFC, the printer device context is automatically created and destroyed and the StartDoc, StartPage, EndPage, and EndDoc
functions are called automatically for you by using member functions in the Cview class.
The most common print function to override is the OnPrint function. You must override this function to print more standard
features such as footers and headers.
Thread-based multitasking allows users to run more than one instance of a program as well as to run different tasks in a single
application. This is similar to running subapplications within a single application.
Every process has a priority class assigned to it. The priority is used to help determine how much central processing unit (CPU)
time that the process has access to.
With multithreading, synchronization becomes a necessity when two or more threads need access to a shared resource that has a
limit on how many threads can access it.
Visual C++ provides many technologies to allow access to databases in your applications. It supports Data Access Objects (DAO),
Open Database Connectivity (ODBC), OLE DB, and ActiveX Data Objects (ADO).
You can access database objects through libraries included in Visual C++, such as MFC, the Active Template Library (ATL), and
the Platform SDK.
ActiveX components are based on newer OLE (Object Link Embedding) and use the Component Object Model. COM defines how
components can interact seamlessly between each other.
A main feature of ActiveX controls is their ability to expose their properties using a primary dispatch interface.
ActiveX methods allow the client to perform functions on the control. Like properties, the methods are implemented by the
primary dispatch interface.
Events in ActiveX are a way for the ActiveX control to notify the container about the control. An event is usually activated by
mouse actions or keystroke actions.
Answers to Exercise 3-3
Platform MFC extension or regular DLL?
Visual Basic MFC regular DLL
Visual C++ MFC extension DLL
Visual J++ MFC regular DLL
Borland C++ MFC extension DLL
Symantec C++ MFC extension DLL
Symantec Caf MFC regular DLL
1. You would like to have customized headers and footers. OnPrint
2. You want to modify the device context. OnPrepareDC
3. You want to set the maximum page count. DoPreparePrinting and OnBeginPrinting
4. After creating objects, you need to overload this function to release the resources created by your objects. OnEndPrinting
1. You want to do a background spell checker. THREAD_PRIORITY_LOWEST
2. You want to defragment your hard drive when the computer is idle. THREAD_PRIORITY_IDLE
3. You want to run a service critical to system operation. THREAD_PRIORITY_TIME_CRITICAL
4. You are creating a standard application. THREAD_PRIORITY_NORMAL
1. You want to do a client/server application. What library should you use? ATL
2. You want to be able to access an Excel spreadsheet. What database object should you use? OLE DB
3. You want to manipulate data in Access. What library should you use? MFC
4. You are creating a standard database application. The database uses a standard ODBC driver. What database object should you
use? ODBC.


Chapter 4: The User Interface
Creating and Integrating Toolbars. 3
Implementing ToolTips for Toolbar Buttons. 10
Implementing and Writing to the Status Bar 11
Creating an Application with the MFC AppWizard. 17
Adding Member Variables. 49
Adding a Message Handler for an Event 56
Two-Minute Drill 65
Navigation for the User Interface
Using the MFC AppWizard
Resource Editors
Using ClassWizard
Microsoft Developer Studio and Visual C++ include a rich set of tools and wizards for handling many of the
everyday programming tasks that are a part of almost every desktop application development project. This
chapter focuses on the tools that aid the developer in creating the visual elements of an application, as well as
two of Developer Studio's most important wizards, AppWizard and ClassWizard.
We'll discuss the typical issues that you may encounter when creating your application's user interface,
including guidelines and principles to follow to ensure your user interface is simple and easy to navigate. We'll
describe how to use and enhance the Microsoft Foundation Classes (MFC) toolbars and status bars, which are
generated by the MFC AppWizard. We'll also look at the capabilities of all the Visual C++ resource editors,
which allow you to create and edit various types of Windows resources such as icons, menus, accelerator
tables, dialog boxes, and strings.
In our discussion of AppWizard, we'll look at the options and steps involved in creating a new MFC project.
Then after seeing how you can enhance your application's user interface with the Visual C++ resource editors,
we'll use ClassWizard to "hook-up" events to code when the user interacts with your application's visual
elements.
At various stages in the chapter we'll create and build upon a simple sample application to provide a practical
demonstration of the concepts discussed in the chapter.
Navigation for the User Interface
Throughout the process of designing and implementing desktop applications using Visual C++, a large amount
of time is spent creating and refining the application's user interface. This process involves designing and
creating the interactive elements of the application such as toolbars, status bars, menus, dialog boxes, and
icons.
One of the biggest challenges in designing and implementing a desktop application comes in the creation of an
effective user interface. The design of your application's interface can affect how a user perceives your
software more than any other factor. Visual C++ and MFC provide the framework on which to build a visually
appealing and conventional user interface.
Careful planning is required to ensure that the user interface exposes all the functionality of your application
while being intuitive and simple enough to allow the end user to quickly learn the application. When
considering your application's user interface, it is important to maintain the visual and functional consistency
that can already be found across the majority of applications running on the Windows platform. This enables
the users of your application to apply their experience of using other applications when they are learning to use
your application. With this in mind, developers are encouraged to follow the Windows user interface design
guidelines, which promote good interface design as well as visual and functional consistency within and across
Windows-based applications.
Close compliance to the Windows user interface design guidelines is especially important when you consider
the role of the user interface in modern desktop applications. Increasingly, the focus of application
development is to separate the user interface from the core functionality of the program. This often takes the
form of a distributed architecture with clear separation of user services, business services, and data services. In
such a model, the user interface should serve only as a tool for the user to concentrate on the task of interacting
with the application data, without being distracted or hindered by an overly complex front end. Fortunately,
Visual C++ and MFC provide all of the resources necessary to create a conventional and consistent user
interface.
Creating and Integrating Toolbars
A toolbar is a special organizational visual element that can manage sets of other controls such as buttons,
button separators, and combo boxes. The primary role of toolbars in desktop applications is to provide quick
access to commonly-used functions.
There are various toolbar styles commonly in use; however, the pervasive style now is the Internet Explorer
flat toolbar shown in Figure 4-1. This style of toolbar is sometimes referred to as a ReBar. These toolbars
provide the user with the additional feedback of seeing the toolbar buttons raise up as the mouse passes over
them.
Figure 1: Internet Explorer's toolbars are an example of the ReBar style of toolbar
Toolbars are usually positioned at the top of the client area of a main application window. Often, however,
toolbars are designed to be dockable, whereby the user can drag and place them on any border of the
application's top-level window or leave them in their own modeless window at any location on the screen. An
application isn't required to expose all of its functionality through toolbars because it may take up far too much
screen space. If your application has a lot of functionality that you would like to have exposed through
toolbars, then it might be a good idea to dedicate a separate, dockable toolbar to each logical group of
commands. You can then allow the user to configure your application so that only the toolbars that they
frequently use are on the screen. MFC allows you to easily create many conventional styles of toolbars,
depending on your choices in the MFC AppWizard.
With Visual C++'s toolbar resource editor, you can perform the following tasks:
Create new toolbars, toolbar buttons, and separators
Convert bitmaps into toolbar resources
Create, move, and edit toolbar buttons and separators
All of the buttons of a toolbar resource are actually stored in a single bitmap. In an MFC project, the bitmap for
the initial AppWizard-generated toolbar is stored in the project's res subdirectory with the name Toolbar.bmp.
The Toolbar editor provides a special view of the underlying bitmap, which closely resembles how the toolbar
should look when your application is running. Figure 4-2 shows the various display elements of the toolbar
editor.
Figure 2: Visual C++'s Toolbar editor is used to edit toolbar resources
The toolbar editor window shows two views of the selected button image separated into two panes. The left
pane is editable, but in practice is only used to preview the button at its run-time size. the right pane is where
you would normally edit the toolbar button. The functionality provided by the toolbar editor is reasonably
straightforward. You can select from several different types of pens and tools on the Graphics toolbar and
select from a range of basic colors from the Color toolbar. Above the two views of the image is the preview
display of your toolbar. The button that currently is being edited is indicated by the fuzzy border.
There are two ways to view the properties of a toolbar button:
Double click it from the preview display
Select it in the toolbar editor preview display, and from the View menu select Properties.
The Toolbar Button properties dialog box is shown in Figure 4-3. Using this dialog box, you can change the
toolbar button's ID, width, height, and prompt. The ID is used by the application to identify the toolbar button
resource. The prompt contains text that will appear in the status bar when the mouse hovers over this toolbar
button; this text is placed in a string table and given the same identifier as the toolbar button. Note that by
design, the MFC AppWizard sets up a convenient association between the initial set of toolbar buttons and
their corresponding menu items whereby they share the same identifier and string resource. This means you
don't have to maintain separate copies of the string for the prompt property of a toolbar button and a menu item
that perform the same function. In addition, in the prompt field of the Toolbar Button Properties dialog box in
Figure 4-3, you'll notice the newline character \n followed by the word New.Any text to the right of the newline
character becomes the tooltip for the toolbar button.
Figure 3: The Toolbar Button properties dialog box allows you to change toolbar button properties
You might have noticed the blank button that is displayed at the right end of the toolbar, in the upper preview
display of the toolbar editor. This button is used to create a new button or separator. Separators on a toolbar
group similar functions into logical sets. For example, the Cut, Copy, and Paste buttons are invariably grouped
together.
When you create a new button, another blank button appears to the right of the edited button, but note that
when you save your toolbar, the blank button is not saved to the underlying bitmap. Saving the toolbar also
updates the application's resource file script with the various resource IDs of the toolbar buttons.
Exam Watch: Often you'll want to add text to your toolbar buttons in the same way Internet Explorer has text
captions for its toolbar buttons. Unfortunately, the toolbar editor doesn't provide any support for this, so you'll
need to use the SetButtonText function from within your code. This function takes two arguments: the first is
the index of the button, and the second is the text for the button identified by the index in the first parameter.
Note that you'll also have to resize the toolbar to ensure that there is room for the text.
Here is a list of common functions that you may have to perform when using the toolbar editor.
How do you create a toolbar button? Assign an ID to the blank button at the right end of the toolbar
by opening its property page and editing its ID field.
Alternatively, you can select the blank button at the right end of
the toolbar, and begin drawing in the image editor. A default
button command ID will be assigned to the new button using the
convention ID_BUTTON<n> where n is a sequential number
representing how many new buttons have been added this way.
How do you move a toolbar button? Drag the button that you want to move to its new location on the
toolbar.
How do you copy buttons from a toolbar to
another toolbar?
Hold down the ctrl key and drag the button to its new location
either on the toolbar or a location on another toolbar.
How do you delete a toolbar button? Select the toolbar button and drag it off the toolbar.
How do you insert a separator before a
button that isn't followed by a space?
Drag the button to the right or down until it overlaps the next
button by about halfway.
button that is followed by a space and then
retain the following space?
Drag the button until the right or bottom edge is just touching
the next button or just overlapping it.
button that is followed by a space and not
retain the following space?
Drag the button to the right or down until it overlaps the next
button about halfway.
How do you remove a separator from
between two buttons?
Drag a button from one side of the separator toward the button
on the other side until it overlaps it about halfway.
Creating a New Toolbar
To insert a new toolbar in your application, you can select Insert Toolbar from the context menu of the Toolbar
folder in the ResourceView tab. This creates a new toolbar with a single blank button. For each new button you
start to draw, a new blank button is added on to the end of the toolbar.
Once you draw the pictures on your toolbar, you can change the properties for each individual button by
double-clicking the button and adjusting the values in the Toolbar button properties dialog box. If the button
will be used to execute the same operation as an existing menu item, then you assign the menu items ID to the
toolbar button. If you entered an ID that corresponds to an existing menu item, then youll notice that the
prompt field is automatically populated with the same description that was applied to the corresponding menu
item. The description in this prompt field will appear on the applications status bar when the mouse hovers
over the toolbar button. At the end of the prompt, you can add a newline character \n and a short description,
which will be used as the tooltip for the toolbar button.
Having finished designing your new toolbar, you should change the toolbar ID. To change the toolbar ID,
right-click the toolbar from the ResourceView and select Properties from the context menu. You will then be
able to change the toolbar ID in the toolbar Properties dialog box. By default, it would probably have been
called IDR_TOOLBAR1, but you may want to give it a more appropriate name that has some relationship to
the context in which it will be used.
A toolbar in an MFC application is actually a CToolBar object declared as a member of your applications
CMainFrame class. Therefore, to add your new toolbar to your application, simply add a member variable to
the protected section of your CMainFrame class definition, as in the following example:
class CMainFrame : public CframeWnd
{
//
protected:
CtoolBar m_wndToolBar1;
};
The toolbar is actually created in the CMainFrame::OnCreate function. OnCreate is called by the MFC
framework just after the window has been created but just before it is shown. You can add your code to create
the new toolbar in this function as follows:
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
//
if (!m_wndToolBar1.CreateEx(this, TBSTYLE_FLAT, WS_CHILD |
WS_VISIBLE | CBRS_TOP |
CBRS_GRIPPER | CBRS_TOOLTIPS |
CBRS_FLYBY | CBRS_SIZE_DYNAMIC)||
!m_wndToolBar1.LoadToolBar(IDR_TOOLBAR1))
{
TRACE0("Failed to create toolbar\n");
return -1; // fail to create
}
EnableDocking(CBRS_ALIGN_ANY);
m_wndToolBar1.EnableDocking(CBRS_ALIGN_ANY);
DockControlBar(&m_wndToolBar1);
//
}
The first part of this code that you add contains two functions that are required to create the toolbar. The first
function, CToolBar::CreateEx, actually creates the toolbar. The first parameter to this function is the only
required parameter and it specifies a pointer to the window that will be the toolbars parent. In this case, it is
the CMainFrame object itself. The second argument specifies additional styles for the toolbar, most notable of
which is the CBRS_TOOLTIPS flag, which activates ToolTips for the toolbar.
The second function, CToolBar::LoadToolBar, associates the toolbar object with the toolbar resource that you
created in the toolbar resource editor. This function takes a single argument that specifies the ID of the toolbar
resource.
The remaining functions in this OnCreate implementation are used to make the toolbar a dockable toolbar. In
order for toolbar docking to be enabled, the first thing you must do is enable docking on the main frame
window with the CFrameWnd::EnableDocking function. Then, docking must be enabled on the toolbar itself
with the CControlBar::EnableDocking function. Finally, you can specify that the initial position of the toolbar
should be docked with a call to CFrameWnd::DockControlBar. Conversely, you can specify that you would
like the toolbar to be undocked or floating by calling CFrameWnd::FloatControlBar.
Implementing ToolTips for Toolbar Buttons
Toolbars also include ToolTips, which are small modeless windows that are briefly displayed when the mouse
lingers over a button for a certain interval. ToolTips are used to proactively give the user some feedback about
the purpose of a button.
In order to activate tooltip support for your toolbar, you need to add the CBRS_TOOLTIPS style to the
dwStyle parameter passed into the CToolBar::Create (or CreateEx) function or the CControlBar::SetBarStyle
function. Then, use the following procedure to specify the tooltip text for each individual button on your
toolbar.
To create a ToolTip for a toolbar button:
1. Open the toolbar editor for your toolbar by double-clicking the toolbar in the ResourceView tab.
2. Double-click the button for which you want to define a tooltip. The toolbar button properties dialog box
will be displayed.
3. In the Prompt field, add a description of the button, followed by a newline character (\n) followed by the
text of the tooltip.
Implementing and Writing to the Status Bar
Status bars give your application a place to display messages and useful information to the user without
interrupting the user. They are normally displayed at the bottom of a window and they consist of several panes,
which can include indicators and a message line. The indicators give the status of such things as Caps Lock,
Scroll Lock and Num Lock. The message panel on the status bar is usually used to display information about
the program status or about a toolbar button or menu item that the user is pointing to with the mouse. Figure
4-4 shows a status bar in action. Notice how a description is displayed on the status bar for the toolbar button
over which the mouse is hovering.
Figure 4: The status bar gives the user feedback about the current operation
Adding a New Status Bar Pane
Youve already seen how simple it is to display text in the status bar when the mouse is over a menu item or a
toolbar button. All that was required was to change the value of the Prompt property for the button or menu
item resource. However sometimes you will want to customize a status bar by adding panes that will be used to
give the user more detailed feedback regarding the status of your application or about a particular operation
that the user is performing.
Use the following steps to add a new pane to a status bar:
First, add a command ID for the new pane. Display the Resource Symbols dialog box, shown in Figure 4-5, by
selecting Resource Symbols from the View menu. This dialog box can display all of the currently defined
symbols for your application's resources.
Figure 5: The Resource Symbols dialog box shows all of your application's currently defined symbols
Add a new symbol by clicking the New button to display the New Symbol dialog box, shown in Figure 4-6.
Call the new status bar pane ID_STATUSPANE1 (in practice you would give a more descriptive name to the
new status pane) and accept the default value for the ID. Click OK and then Close to add the new symbol.
Figure 6: The New Symbol dialog box lets you add a new resource symbol
Next, you must assign a default caption for the new status bar pane. The length of this default string will
determine the initial width of the status pane. To define the string, open the String Table resource editor by
double clicking the string table in the ResourceView tab of your project's workspace. Then, display the String
Properties dialog box, shown in Figure 4-7, for a new string by selecting New String from the context menu
which appears when you right-click inside the string table resource editor.
Figure 7: Use the String Properties dialog box to define the default caption for the new status pane
In the ID field of the String Properties dialog box, type the same ID that you assigned to the new pane in the
Resource Symbols dialog box. In this case, type ID_STATUSPANE1. Then, in the caption field, enter the
default caption that you would like to appear in the status pane. close the String Properties dialog box and close
the String Table resource editor.
Next, you need to add your new pane to your application's status bar's indicators array. A status bar in an MFC
application is usually initialized in the CMainFrame::OnCreate function. During the initialization of the status
bar, a call is made to CStatusBar::SetIndicators that pass in an array of IDs that determine the order and type of
panes to display in the status bar. In a normal MFC AppWizard-generated project, this array is defined near the
top of the file called MainFrm.cpp. You can use the FileView tab of your project workspace to open
MainFrm.cpp. All you have to do to activate your new status pane is add its ID to the array in the position that
you would like it to appear, so that the array should now look something like this:
static UINT indicators[] =
{
ID_SEPARATOR, // status line indicator
ID_STATUSPANE1, // our new status pane
ID_INDICATOR_CAPS,
ID_INDICATOR_NUM,
ID_INDICATOR_SCRL,
};
Now when you recompile and execute your application, you will see the new status bar pane with your default
text. However, it isn't much good if you aren't able to dynamically change the text that is displayed in it. So to
make the status bar pane fully functional, you create an UPDATE_COMMAND_UI event handler that you will
subsequently be able to use to set the text in the pane.
You would normally use ClassWizard to set up the mechanism for messages to be caught, but ClassWizard
doesn't allow you to catch status bar messages. Therefore, you must manually add the event handler entries to
the MFC message maps and create the code for the message handler. Note that any code between the
AFX_MSG_MAP and the AFX_MSG comments is used by ClassWizard and generally shouldn't be modified.
we will be adding our event handler entries outside the ClassWizard blocks.
First, we'll change the message map entries in the header file for your CMainFrame class. you can open this file
by double-clicking the CMainFrame class in the ClassView tab of the project workspace. The message map
appears near the end of the file. Modify this message map by adding in the OnUpdateStatusPane1 entry so
that it looks like the following listing:
//{{AFX_MSG(CMainFrame)
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
// NOTE - the ClassWizard will add and remove member functions here.
// DO NOT EDIT what you see in these blocks of generated code!
//}}AFX_MSG
afx_msg void OnUpdateStatusPane1(CCmdUI *pCmdUI);
DECLARE_MESSAGE_MAP()
Next, you need to add the handler to the message map in the class implementation file in order to associate the
status pane's resource symbol with your handler function. This message map is located in the MainFrm.cpp
file. Open this file by double-clicking it from the FileView tab in your project workspace. The message map
will be located somewhere near the top of the file. Once you've found it, add the
ON_UPDATE_COMMAND_UI entry so that it looks like the following listing:
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
//{{AFX_MSG_MAP(CMainFrame)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code !
ON_WM_CREATE()
//}}AFX_MSG_MAP
ON_UPDATE_COMMAND_UI(ID_STATUSPANE1, OnUpdateStatusPane1)
END_MESSAGE_MAP()
The mechanism is now in place for the function OnUpdateStatusPane1 to be called whenever the status bar
pane ID_STATUSPANE1 needs to be updated. All that remains is to add the actual handler function itself. To
do this, copy the code from the following listing into the very bottom of the MainFrm.cpp file.
void CMainFrame::OnUpdateStatusPane1(CCmdUI *pCmdUI)
{
CTime theTime = CTime::GetCurrentTime();
CString sStatusText = theTime.Format("%H:%M:%S");
CClientDC dc(this);
SIZE size = dc.GetTextExtent(sStatusText);
int index = m_wndStatusBar.CommandToIndex(ID_STATUSPANE1);
m_wndStatusBar.SetPaneInfo(index,ID_STATUSPANE1, SBPS_POPOUT, size.cx);
pCmdUI->Enable();
pCmdUI->SetText(sStatusText);
}
The parameter to this message handler function is a pointer to a CCmdUI object. The CCmdUI class is always
used within the handler of the ON_UPDATE_COMMAND_UI message. The handler can call member
functions of the CCmdUI object to update the status bar pane. The following list describes the purpose of the
CCmdUI member functions as they apply to the updating of a status bar pane:
CCmdUI::EnableMakes text in the status bar pane visible or invisible
CCmdUI::SetCheckChanges the border of the status bar pane to be a pop-out (raised) border or a
normal border
CCmdUI::SetRadioSame as SetCheck
CCmdUI::SetTextSets the text to display in the status bar pane
You should now be able to recompile and run your application. You'll notice that the updating of the time in
the pane is relatively irregular. This is because the triggering of the message depends on when the application
enters an idle state, and that is dependant on many factors. In fact this method of implementing a clock in the
status bar may not be entirely practical in a real application and only serves as an example of how to change the
text in a status bar pane.
In the handler function, we are simply formatting and displaying the current time in our new status bar pane.
These types of user interface update handlers should do as little as possible because they can tend to be called
very often. This particular handler will be triggered whenever the application is idle.
The first thing we do in the handler is obtain and format the current time, which is then saved in the StatusText
variable. Then, we determine how wide the pane will need to be in order to draw the text. this is done with the
call to GetTextExtent, using a device context from the main frame window. Then, we obtain the index of our
pane through a call to the CommandToIndex function of the status bar member. The index is used to set the
width of our pane in a call to SetPaneInfo. notice also in this call that we set a flag which gives the status bar
pane a raised bevel effect. finally, we ensure that the status bar pane is in fact enabled and we set its text value
with a call to SetText, passing in the formatted string containing the current time.
Using the MFC AppWizard
The starting point of many Microsoft Visual C++ projects is the AppWizard. The MFC AppWizard gives
developers a great head start when beginning a new Windows-based program using MFC. AppWizard helps
you generate the basic source files for a variety of different types of Windows-based programs, allowing you to
get down to the task of creating your application. The extensive amounts of AppWizard-generated code
handles many routine programming tasks, freeing the developer to concentrate on implementing program
functionality. It is possible to use Visual C++ to create a Windows-based program without using AppWizard,
but the range of project types available in AppWizard make it the sensible choice for any Visual C++ project.
Creating an Application with the MFC AppWizard
We'll now walk through the steps involved in creating a new Visual C++ project using the MFC AppWizard. In
this exercise, you'll create a simple MFC executable application to demonstrate the features of the MFC
AppWizard. On completion of this exercise you will know about the following items:
Identification of the different MFC project types supported by AppWizard
How to create a new Visual C++ project and project workspace
The optional features that can be added to an MFC application through AppWizard
The initial source files that AppWizard generates
How to compile and run the newly-created MFC AppWizard project
To use the MFC AppWizard to create a new Visual C++ project, select File | New and select the Projects tab
from the new dialog box as shown in Figure 4-8. Choose MFC AppWizard (EXE) from the list of project types
on the left, give the project the name MFCWiz, and click OK.
Figure 8: Select the MFC AppWizard project type from the Project tab of the New dialog box
Step 1 of the MFC AppWizard is shown in Figure 4-9. This step requires you to decide upon the basic
characteristics of your application, such as whether it will be a single-document interface (SDI), a
multiple-document interface (MDI), or a Dialog-based application.
Figure 9: Step 1 of the MFC AppWizard requires you to choose the type of application that you wish to build
There are three main types of application architecture supported by the MFC AppWizard:
A single-document interface application can only present one document to the user at any given time. A
simple example of an SDI is Windows Notepad. Choosing this option will create an application with a view
class based on CView.
A multiple-document interface application can present the user with several documents at once, each in
its own child window. An example of a MDI application is Microsoft Word. MDI applications are also based
by default on the CView class.
A Dialog-based application such as Windows Character Map, is based on the CDialog class and typically
displays a single dialog box to the user.
Beneath the choice of application type is a check box that allows you to indicate whether you want support for
the document/view architecture using the CDocument and the CView base classes. You would probably clear
this check box if you were porting an application from another development environment. However, an
application without the document/view architecture wont have MFC support for opening a file from a disk.
Further down on the screen is a drop-down list box that allows you to select the language for your applications
resources. The drop-down list displays the languages available on your system. If you wish to use a language
other than English, the appropriate DLL for that language must be installed on your system. The DLLs follow a
naming convention of AppWzxxx.dll, where xxx is a three-letter language identifier.
For the purposes of this demonstration, we are going to create an SDI application with document/view
architecture and English (United States) resources. Select the appropriate options and click Next.
Step 2 of the MFC AppWizard, shown in Figure 4-10, is to select the desired level of database support for your
application.
Figure 10: Step 2 of the MFC AppWizard is to select the desired level of database support
There are four levels of database support for MFC applications:
The default option is None, which specifies that you do not wish AppWizard to include support for
database access in your application.
The next level of support, Header files only, gives your application a basic level of database support
whereby a header file, AFXDB.H, and link libraries are created but no database-specific classes are generated.
This allows you to create recordsets and use them to view and update records from a database.
The third level of support, Database view without file support, includes the header and link libraries as
well as a record view and a recordset class. Choosing this option will give your program a
CrecordView-derived view class. AppWizard will also create a Crecordset-derived class that will be associated
with your view class. This option includes document support but no serialization support. A form-based
application will be created in which the record view is used to view and update records through its recordset.
The final level of database support is Database view with file support. This option will create an
application similar to an application created with the previous level of support, except that this application will
also support document serialization. If you choose either of the levels of database support that include a
database view, you will also have to specify a data source for the application.
The purpose of this exercise isnt to create a database application, so we will select None as our level of
database support and click Next.
Step 3 of the MFC AppWizard, shown in Figure 4-11, is concerned with selecting the amount of ActiveX and
compound document support for your application.
Figure 11: Step 3 of AppWizard allows you to specify ActiveX options
There are five choices for compound document support:
The default option is to not include support for compound documents in your application.
The next option, Container, allows your application to contain embedded or linked ActiveX objects, such
as Word documents.
The next option, Mini Server, specifies an application that has the ability to create and manage compound
document objects that can be embedded in other applications, but it cant run as a standalone application.
To have an application that can create and manage compound document objects such as the Mini Server,
but also run as a standalone application, choose Full Server.
Choosing Both Container and Server creates an application that can contain embedded or linked objects
from other applications as well as create and manage its own document objects for other applications to use.
If you choose to support compound documents, you can also support compound files. Files saved in the
compound file format can contain several automation objects, and those objects are stored in such a way that
objects can be changed without rewriting the whole file. This can greatly improve the efficiency of your
application. You can use the option buttons in the middle of the Step 3 dialog box to say Yes, Please, or No,
Thank You to compound files.
If you want your application to surrender control to other applications through automation, or if you would like
your application to control other applications through automation, select the Automation check box. In
addition, if you intend to use ActiveX controls in your application, select the ActiveX Controls check box.
In our exercise we will take all the defaults for this step and move on to step 4.
Step 4 of the MFC AppWizard, shown in Figure 4-12, is concerned with selecting some of the common
features of Windows-based applications such as toolbars, status bars, and print preview support.
Figure 12: Step 4 of the MFC AppWizard allows you to specify the common features that your application will
support
The various options for Step 4 of the MFC AppWizard are described in the following list:
Select the Docking Toolbar check box to include a toolbar in your application. The toolbar that is created
for you will include buttons for various common operations such as Cut, Copy, and Paste. A couple of menu
items will also be created for you to allow the user to choose whether to hide or show the toolbar. Notice that a
dockable toolbar will be created by default.
Select the Initial Status Bar check box to include a status bar in your application. The default status bar
will include panels that display the status of the Caps Lock, Num Lock, and Scroll Lock keys as well as a panel
that displays information when the mouse is passed over menu items. Just like the toolbar, some menu
commands will be added to allow the user to choose whether to hide or show the status bar.
For applications using the document/view architecture, the Print and Print Preview check box enables
AppWizard to generate code that will handle print, print setup, and print preview commands. Menu items will
be created for these operations.
Selecting the Context Sensitive Help check box will generate a set of help files that you can compile with
the help compiler.
The 3D Controls check box is selected by default and it allows the controls that appear in your
application to have 3D shading.
Selecting the MAPI check box will include support for the Messaging Application Programming
Interface in your application.
Selecting Windows Sockets will include Winsock support in your application. Winsock support will
enable your application to take part in interprocess communication (IPC) through Transmission Control
Protocol/Internet Protocol (TCP/IP).
If you chose to include a toolbar in your application, you will be able to specify the style of toolbar you
prefer. The Normal option button will produce a traditional style of toolbar with a simple list of buttons. The
Internet Explorer ReBars option button will create toolbars like those in Internet Explorer, which are capable of
containing standard windows controls such as combo boxes.
The edit box at the base of the Step 4 wizard form allows you to select the number of files to show in the
recently used file list of your application's File menu.
The Advanced button displays another dialog box that allows you to specify options for document template
strings and frame characteristics. The first tab of the Advanced Options dialog box is shown in Figure 4-13.
This tab allows you to specify a file extension for your document type as well as various strings that identify
your application's document type and may require localization. These strings are kept in the resource script of
the application where they are associated with the resource ID of the main frame window of the application.
Figure 13: The first tab of the Advanced Options dialog box allows you to specify options for document
template strings
The second tab of the Advanced Options dialog box, titled Window Styles, is shown in Figure 4-14.
Figure 14: The Window Styles tab of the Advanced Options dialog box allows you to specify various flags that
affect the appearance of your application's window
This tab allows you to choose to use a split window in your application. Selecting this option will insert a split
bar in your application's main views. In an MDI application, the client area of the child windows will contain
the split bar, whereas in an SDI application, the client area of the main application window will contain the
split bar. Recall that we chose to build an SDI application back in Step 1 of the AppWizard and so the MDI
section of Figure 4-14 is disabled.
The other options on the Window Styles tab are explained here:
Selecting the Thick Frame check box will give your application window a thick edge and the user will be
able to resize the window. Clearing this option prevents resizing.
The Minimize Box check box determines whether your application window will have a minimize button
in the top-right corner.
The Maximize Box check box determines whether your application window will have a maximize button
in the top-right corner.
The System Menu check box determines whether your application window will have a System menu in
the top-left corner of the main window. The System menu is a special pop-up menu that is located in the far left
of an application's title bar. It typically includes the Close, Restore, Move, Size, Minimize, and Maximize
commands.
Selecting the Minimized check box causes your application to be minimized when the application starts.
Selecting the Maximized check box causes your application to be maximized when the application starts.
Once again we will stay with the defaults for all the options in Step 4 and click Next to move on to Step 5.
Step 5 of the MFC AppWizard is shown in Figure 4-15. The items in Step 5 aren't logically grouped together;
they are more of a miscellaneous collection of the remaining information that AppWizard collects.
Figure 15: Step 5 of AppWizard includes some miscellaneous options
The first choice that you are required to make concerns the style of application that will be created. The default
is to create a standard MFC application using the normal MFC architecture. The alternative is to create an
Explorer-like application using a split window, where the left pane is a CTreeView and the right pane is a
CListView.
The next set of option buttons is concerned with choosing whether you would like the MFC AppWizard to
generate source code comments for your application. These comments include prompts telling you where to
add your code. a ReadMe.txt file will be generated in your project directory. This ReadMe.txt file contains
comprehensive information regarding all of the files generated by AppWizard.
The next question asks if you would like the MFC libraries installed as a shared DLL or statically linked to
your application. Using MFC as a shared DLL will reduce the size of your application's executable, but may
introduce complex distribution issues. Choosing to statically link your application to the MFC libraries at build
time will produce a much larger executable, but it may be simpler to distribute.
The final step of the MFC AppWizard involves reviewing and confirming the names, filenames, and base
classes of the classes that AppWizard will generate. Step 6 is shown in Figure 4-16.
Figure 16: Step 6 of the AppWizard allows you to change filenames, class names, and base classes
By default, AppWizard creates names for your application classes and files based on an abbreviation of your
project name. The majority of the time, you won't want to change the default names. if the Base Class combo
box is enabled, you will be able to select a different class from which to derive your new class. This option
usually only applies to your application's view class. The default is CView, but depending on the type of
application that you are building, you may wish to use another view class, such as CFormView, CscrollView,
or CEditView.
Accept the defaults on the final step and click Finish. You will be shown a summary of all the options that you
have selected for your application. When you are happy with the selected options, click OK and the project
workspace will be created. You can build and run your application immediately by selecting Build and then
Execute from the Build menu.
On the Job: Sometimes you'll want AppWizard to generate code with different options after you have run
AppWizard. AppWizard is a one-time process that you perform at the start of a project. This doesn't give you
the opportunity to go back and change options if a new requirement arises at some later stage in the
development process. Say, for example, your client suddenly requires that you include Winsock support in
your application in order to talk to an external system through TCP/IP. we'll look now at a technique that you
can use to still use AppWizard to generate the code that you require.
AppWizard works by piecing together bits of code according to the options that you select. Therefore, if you
know exactly what code AppWizard adds into a project to support the feature that you require, you will be able
to paste the feature in yourself. Visual C++ includes a tool called WinDiff that can help you do exactly that.
Follow these steps to add an AppWizard-generated feature to your existing MFC application:
1. use AppWizard to create a new project with exactly the same options you used to create the existing
project.
2. Next, create a second new project in a different folder with the same name and all the same settings but
also specify the option that you wish to add in (for example, Winsock support).
3. compare the two directories of the new projects using WinDiff. You'll be able to use the results of
WinDiff to discover which parts of the code from the second new project need to be copied into your original
project to implement the feature that you want to add.
Resource Editors
A Windows-based desktop application makes use of resources defined in a resource file, which is simply a text
file with the extension .RC. A Windows resource file contains a script with various statements that define
resources. For resources that exist in separate files, such as icons and cursors, the script specifies the resource
and the file that contains it. For certain resources, such as string tables and menus, the entire definition of the
resource exists within the script. Visual C++ provides a rich set of tools to simplify the task of editing resource
files and visual elements, allowing the developer to easily use and enhance the initial user interface produced
by AppWizard.
Although Visual C++ provides many tools to edit resource files visually, there may be times when you want to
view the contents of your project resource file as text. For example, you may want to perform a multiple find
and replace of a string, or perhaps you are curious to see how much resource script the Visual C++ editors
automatically generate for you. You could, of course, open the .RC file in a simple editor such as notepad, but
the file can also be opened as text within Developer Studio. Developer Studio will display it with full-color
coding and give you all the benefits of the Developer Studio environment, such as the Find and Replace dialog
box.
To open a resource file (.RC) as text, follow these steps:
1. From the File menu choose Open, and use the open dialog box to navigate to the resource file (.RC) that
you wish to view.
2. From the Open as drop-down list, select Text and click the Open button.
It is understood that any manual modification of Visual C++-generated resource scripts should be performed
with great care.
The ResourceView Tab
Now that youve looked at the underlying content of an AppWizard-generated resource file, the next logical
step is to review the tools available within Visual C++ to make editing of your desktop applications resources
as painless as possible. To see all of your applications resources represented in the Visual C++ ResourceView
tab, use the MFC AppWizard to create a new project, and click the ResourceView tab at the base of the Project
Workspace window. You will see a list of the project resources, as Figure 4-17 shows.
Figure 17: The ResourceView allows you to view your project resources
Expanding the folder for each resource type shows the individual resources of that type in your project. You
can right-click this window to bring up a shortcut menu of commands. you can double-click any resource to
invoke its resource editor. Right-clicking a resource displays a context menu that allows you to insert new
resources. When you select Insert from this context menu, you are presented with the Insert Resource dialog
box shown in Figure 4-18. this dialog box is also available by selecting Resource from the Insert menu.
Alternatively, the context menu will always have a command that allows you to immediately create a new
resource of the type on which you right-clicked.
Figure 18: The Insert Resource dialog box lists the various types of resources that you can create in Visual C++
When a new resource is added to your project, it is automatically given a unique name. For example, a new
dialog box resource may be given the name IDD_DIALOG1, then the next dialog box resource added to the
project will be called IDD_DIALOG2. It is common convention, however, to change the generated name to
one that more accurately reflects the purpose of the particular resource in the context of your application. To
view the names of all the resources in the project, select Resource Symbols from the View menu. The Resource
Symbols dialog box is shown in Figure 4-19.
Figure 19: The Resource Symbols dialog box can be used to find a resource from its symbolic name
On occasion, you may find it convenient to use the Resource Symbols dialog box to locate a particular resource
from its symbolic name. When you have located a resource in the Resource Symbols dialog box, you can go to
it by selecting the name in the list and clicking the View Use button.
In the following sections, we will briefly describe each of the types of resources that can be created and look at
their respective resource editors.
Accelerator Editor
An accelerator table contains a list of accelerator keys (or shortcut keys) and the command identifiers that are
associated with them. A program can have more than one accelerator table. Accelerators are usually used as
keyboard shortcuts for program commands that appear on your application's menu or toolbar. However, they
can also be used to define key combinations for commands that dont have a corresponding user-interface
object. Figure 4-20 shows the Accelerator editor.
Figure 20: Use the Accelerator editor to edit accelerator table resources
You can perform the following actions with the Accelerator editor:
View, add, edit, and delete accelerator key assignments on individual or multiple accelerator keys
View and change the resource identifier associated with each entry in the accelerator table. The identifier
is used to reference each accelerator table entry in your code.
Associate an accelerator key with a menu item
You can display the Accel Properties dialog box shown in Figure 4-21 by double-clicking an accelerator key,
or from its context menu. This property page allows you to control the values associated with each accelerator
key.
Figure 21: The Accel Properties dialog allows you to edit accelerator keys
Exam Watch: To associate a menu item with a keyboard combination, simply assign the same resource
identifier to both the menu item and the relevant entry in the accelerator table. It's often appropriate to edit the
menu item's caption to show the name of the accelerator, as this isn't done automatically. Refer to the section
on the Menu editor to see how to do this.
Binary Editor
The Binary editor, shown in Figure 4-22, allows you to edit resources at the binary level in either hexadecimal
format or ASCII format. it also can be used with the Find command to search for either ASCII strings or
hexadecimal bytes with the binary resource. Binary resources are usually custom resources, such as WAV files,
for which native editing support isn't provided by the Visual C++ environment. For this reason, it may not
always be the most appropriate tool to use for such resources, and incorrect editing of the resource at the binary
level could cause the resource to be corrupted.
Figure 22: The Binary editor lets you edit custom resources
You can bring a new custom resource into your project by placing the resource in a separate .RC file using
normal resource script file syntax, and then including that file by using the Resource Includes command from
the View menu. When the Resource Includes dialog box, shown in Figure 4-23, is displayed, you can type an
#include statement in the Compile Time Directives edit box that gives the name of the file containing your
custom resource. For example, you could type #include myres.rc.
Figure 23: The Resource Includes dialog box allows you to insert custom resources into your project
Take care to ensure that the spelling and the syntax of all entries in the Compile Time Directives edit box are
accurate, because this text is copied directly into your project's resource script.
Dialog Editor
The Dialog editor, shown in Figure 4-24, can be used to create or edit dialog boxes. Dialog boxes that you
create can be stored as templates so that you can reuse them.
Figure 24: Use the Dialog editor to create and edit dialog boxes
The Dialog editor allows you to perform the following tasks:
Add, arrange, or edit controls on a dialog box
Change the tab order of controls on a dialog box
Use guides in the dialog box layout to position controls precisely
Preview the dialog box as it will appear when your application is running
Create message handlers for the dialog box and its controls
Jump to the code that implements the dialog box and its controls
You can add controls to a dialog box by using the Controls toolbar, which enables you to choose the control
that you want and then drag it to the dialog box. You can also add additional ActiveX controls to the Controls
toolbox by using the Insert ActiveX Controls command from the context menu of the Dialog editor. You can
change the properties of controls that are in your dialog box by using the controls property page. The property
page for a control can be displayed by selecting Properties from the context menu of the control. You can also
select multiple controls and change their common properties all at the same time.
Double-clicking a dialog box control will take you to the handler code for that control. If a handler function
didn't already exist, then a stub handler function will be created. In addition, you can double-click the dialog
box itself to jump to its class definition. Windows controls usually have a range of events and messages
available to them, you can create and edit handler functions for these events by selecting the Events item from
the context menu for the control.
To preview some of the run-time behavior of your dialog box, select Test from the Layout menu. This can
speed up the process of building a dialog box by giving you immediate feedback on how the dialog box will
look and feel to the end user.
Graphics Editor
The Graphics editor, shown in Figure 4-25, has an extensive set of tools for creating and editing bitmaps, icons,
and cursors, as well as integrated features to support the creation of toolbar bitmaps. In addition to creating and
editing images in bitmap format, you can edit bitmap images and save them in GIF or JPEG format. You can
also convert images in GIF or JPEG format to bitmap format.
Figure 25: The Graphics editor is shown here editing an icon resource
Within the Graphics editor workspace, the Image Editor window shows two views of your image resource. The
size of the two panes can be adjusted by the split bar that separates them. Also within the Graphics editor is the
Graphics toolbar, which consists of the following two sections:
A toolbar, which contains various tools, shapes, and brushes for drawing, painting, entering text, erasing,
and manipulating views
An option selector, which can be used to select brush widths and other drawing options
In addition, the Graphics editor provides the Colors palette, which consists of an indicator showing the current
foreground and background colors and selectors for screen and inverse colors. It also has a range of colors from
which to select the foreground and background colors. The foreground color is selected by clicking a color in
the Colors palette. a background color is selected by right-clicking a color in the Colors palette.
On the Job: When creating images for an application that you plan to distribute internationally, it is important
to take into account various localization issues. It can be challenging to design bitmaps that are simple and
specific enough to identify a command and at the same time ensure that they avoid cultural references and
stereotypes that could offend international users. You could keep separate versions of bitmaps for different
language editions of your application; however, this can be very time consuming. A better approach may be to
take advantage of the common toolbar buttons defined for Windows or to use internationally recognized
symbols, such as those used on road signs or in airports.
Another internationalization issue to keep in mind when using image resources is that it is generally best to
keep images free of letters that represent the first letters of commands, such as B for Bold. You certainly
should not include text in images unless the text is not intended to be translated (for example, a company
name). An alternative might be to retrieve the text from a locale-specific string table and use Win32 API calls
to draw the text onto the image.
HTML Resources
A Hypertext Markup Language (HTML) resource is an HTML file that is stored and compiled as part of your
resource script. When you create a new HTML resource, Visual C++ includes it in the resource script of the
active project, providing you with easy access to the HTML page.
HTML resources were introduced to support the CHtmlView class; however, you can insert them into any
project and use them as you would any other resource. With the HTML resource editor, you can create an
HTML page using the text editor's native support for syntax coloring of HTML tags. Figure 4-26 shows an
HTML page being edited in the text editor. You can easily preview the page as you develop it by selecting
Preview from the context menu that appears within the text editor.
Figure 26: The Text editor natively supports syntax coloring for HTML resources
When you create a new HTML page or import an existing one, if your page contains bitmaps or other such
graphics, you should be sure to import the relevant images into your project's resource script. This ensures the
availability of the images when the application is run on the end user's PC. You should use the res:// protocol
to display such graphic images in your page. The res:// protocol supports the retrieving and displaying of a
resource that resides in a compiled .DLL or .EXE module.
Menu Editor
Windows menu resources allow you to arrange commands in a logical, easy-to-find fashion. With the Menu
editor, shown in Figure 4-27, you can create and edit menus by working directly with a menu bar that closely
mimics the behavior of the menu as it would appear in the finished application.
Figure 27: The Menu editor creates and edits menu items while emulating the run-time behavior of your
application's menu bar
With the Menu editor, you can perform the following tasks:
Create standard menus and commands
Move menus or commands from one place to another
Edit the properties of several menu items at the same time
Double-clicking a menu item displays the Menu Item Properties dialog box. From there, you can change many
properties of the menu item, such as whether it is checked, inactive, or unavailable. You can also set the
caption of the menu item from the Caption field in the Properties dialog box. Following the menu caption text,
you can type the tab escape character (\t), followed by text representing the menus accelerator keys. At run
time, this will show the menu's caption in the format familiar to users, where the menu caption text is
left-aligned and the text describing the accelerator keys for the menu is right-aligned.
Adding new menu items is simple using the Menu editor. All you have to do is select the new item box (the
empty rectangle) on the menu bar, or use your mouse to move the new item box to the appropriate position and
type the menu item's caption. Note that when you are typing the caption, you can define a mnemonic key that
allows the user to select the menu with the keyboard. to do this, type an ampersand (&) in front of a letter to
specify it as the mnemonic, then at run time, that letter will appear underlined. You should take care to ensure
that all the mnemonics on a menu bar are unique.
String Editor
A string table is a Windows resource that contains a list of IDs, values, and captions for all the strings of your
application. For example, the status bar prompts that appear as your mouse moves over menu items are located
in the string table. String tables make it easy to localize your application into different languages. If all text that
could be displayed in your application is kept in a string table, you can localize the application by translating
the strings and still maintain common source code for international editions of the application.
With the String editor, shown in Figure 4-28, you can edit your application's string table resource. In a string
table, strings are grouped into segments, or blocks, of 16 strings each. The segment that a string belongs to is
determined by the value of its identifier. For example, strings with identifiers of 0 to 15 are in one segment,
strings with identifiers of 16 to 31 are in a second segment, and so on. Thus, to move a string from one segment
to another you only need to change its identifier.
Segments of the string table are loaded into memory on demand. For this reason, it is a good idea to try to
organize your application's string resources into logical groups within 16-string segments that are likely to be
required at the same time. This ensures that memory is used as efficiently as possible by not keeping the entire
string table in memory when only a few strings may be required at any given time.
Figure 28: The String editor lets you create and edit string resources
Double-clicking a string in the String editor will display its property page, which allows you to edit the string's
ID or caption. You can also select multiple strings and change their properties all at the same time.
Version Information Editor
A version resource consists of company and product identification such as a product version number, and
copyright and trademark information. The Version Information editor, shown in Figure 4-29, is a tool for
creating and maintaining this data.
Figure 29: The Version Information editor allows you to embed information, such as your company name, into
your application
A Windows-based application isn't required to contain version information to run, but it would be
unconventional not to have a version resource. Note that the Windows standard name for an application version
resource is VS_VERSION_INFO. The known formatting of version resources allow the version information to
be accessed from other applications. In order to access your application's version information
programmatically, you should use of the GetFileVersionInfo and VerQueryValue Win32 APIs.
Using ClassWizard
Most developers spend a significant amount of time in the early stages of a desktop project working
exclusively on the visual elements of their application before moving on to the application-specific
functionality. At some stage in the development process, it is necessary to hook-up the user interface objects to
the core functionality of the application. Visual C++ provides a reliable framework within which to achieve
this. The principle that tool Visual C++ provides to you to perform these tasks is ClassWizard.
Some of the operations that ClassWizard assists you with include creating new classes, defining message
handlers, creating virtual function overrides, and mapping data from dialog box controls to class members.
ClassWizard only works with MFC applications.
Figure 30: Use the MFC Class Wizard to create new classes, define message handlers, override virtual
functions, and gather data from controls
The user interface of ClassWizard is a tabbed dialog box, as shown in Figure 4-30. you can access ClassWizard
by selecting ClassWizard from the View menu. The following list describes the use of each tab:
Message MapsUse the Message Maps tab to browse the messages that a class can handle and to create,
edit, and delete the member functions mapped to the messages. You can also use the Edit Code button to jump
straight to a message handler function's code.
Member VariablesUse the Member Variables tab to bind member variables to dialog, form view, or
record view controls. You can also bind record view member variables to both record view controls and to the
columns of a table in your data source.
AutomationUse the Automation tab to create and edit the Automation aspects of your application. For
example, you can create Automation properties and methods that allow other applications to control your
application.
ActiveX EventsIf your project includes a class that implements an ActiveX control, you can use the
ActiveX Events tab to specify which actions will cause events to fire in your ActiveX control. For example,
you can specify that an event will be raised in the control's container in response to a user's mouse-click.
Class InfoUse the Class Info tab to browse and set general class options. You can set the message filter
to determine what messages ClassWizard offers to map to handlers. You can also view or set a foreign object
associated with your dialog form view or record view class.
In addition, on every tab of the ClassWizard is the Add Class button. This button allows you to create a class,
import a class from a file, or import a class from an ActiveX type library.
Adding Member Variables
You can use ClassWizard to add member variables to dialog classes to represent the dialog box's controls. The
mechanism of mapping a dialog control to a dialog class member variable is called Dialog Data Exchange
(DDX). DDX eliminates the need for you to transfer data between the control and its corresponding member
variable yourself.
We will do an exercise now that demonstrates creating a simple dialog resource and associating it with a dialog
class based on CDialog that includes member variables that map to each of the controls in the dialog resource
through DDX.
For each dialog box in your application, you need to have a dialog box resource and a dialog box class. The
resource script commands making up the dialog box resource are interpreted to determine how the dialog box
should be drawn on screen when your application is running. The dialog box class contains member variables
that hold the values of the controls in your dialog box and it also contains member functions that create and
show your dialog box. The dialog box resource is built with the dialog resource editor. ClassWizard is used to
create and manage the dialog box class.
To start the exercise, use AppWizard to create a new SDI MFC executable application. select the
ResourceView tab from the project workspace and choose Insert from the context menu that appears when you
right-click inside the ResourceView tab. The Insert Resource dialog box will appear. From this dialog box,
select Dialog and click New or double-click Dialog. A simple dialog box with an ID of IDD_DIALOG1 should
appear in the dialog resource editor, as shown in Figure 4-31.
Figure 31: The Dialog resource editor lets you add user interface elements to a dialog resource
Now display the Properties dialog box by right-clicking somewhere inside the dialog box and selecting
Properties from the context menu. The Properties dialog box, shown in Figure 4-32, is used frequently when
modifying a dialog box resource. Because of this, you might find it useful to click the pushpin button in the
top-left corner, which will cause the Properties dialog box to become a modeless dialog box that will float on
the screen while the dialog resource editor is open. Using the Properties dialog box, change the ID of the dialog
box resource to IDD_TESTDIALOG and change the Caption to Test Dialog.
Figure 32: The Properties dialog box lets you change values that affect the appearance of the dialog box
resource
You can add controls to your dialog box resource by dragging and dropping them from the control palette,
which is pictured on the right side of the resource editor workspace in Figure 4-31. Because the purpose of this
exercise is to demonstrate ClassWizard functionality rather than how to use all of the common user interface
elements, we'll keep this dialog box simple by just adding a single Static Text control and a single Edit Box
control. Use your mouse to drag each of those controls to somewhere in the middle of your dialog box. Select
Static Text and use the Properties dialog box to change its caption to say Enter some text:. Now select Test
from the Layout menu and you'll be presented with a preview of the dialog box, which should look something
like Figure 4-33. You can close the preview dialog box by clicking either of its command buttons.
Figure 33: The preview of your dialog box as it will appear in your running application
Now that the dialog resource is complete, its time to create the dialog class. Bring up ClassWizard by
choosing ClassWizard from the View menu or by double-clicking somewhere within the dialog box in the
resource editor. ClassWizard knows that you haven't yet defined a dialog class for this resource and so it offers
to create one for you, as in Figure 4-34.
Figure 34: ClassWizard offers to create a dialog class for your new dialog resource
Accept the default option of creating a new class and click OK. The New Class dialog box will appear as in
Figure 4-35. Give your class a class name of CTestDialog. Notice that the base class for this dialog will be the
MFC CDialog class and that ClassWizard has already associated your dialog's resource symbol with the new
class. When you click OK to create the class, two new files will be created in the directory in which your
project resides, TestDialog.cpp and TestDialog.h.
Figure 35: The New Class dialog box enables you to create a new class based on CDialog
Now you can use the Member Variables tab of ClassWizard to connect the dialog box controls to member
variables in your class. The Member Variables tab of ClassWizard, in Figure 4-36, shows a list of the control
IDs for the dialog resource associated with the dialog class displayed in the Class Name combo box.
Figure 36: The Member Variables tab of ClassWizard enables you to connect dialog controls to member
variables
We'll now connect a member variable to the Edit Box on our dialog box by highlighting IDC_EDIT1 in the
Control IDs list and clicking the Add Variable button. The Add Member Variable dialog box shown in Figure
4-37 will be displayed. In the member variable name field, give the variable the name m_EditBox. You'll
notice that ClassWizard suggests a prefix of m_ for the variable; this is the convention that is used to identify
member variables in MFC applications. The Category combo box lets you specify whether this is a value
variable or a control variable. For standard Windows controls such as the Edit Box, you should choose Value
to create a variable that will contain the text or status of the control as entered by the user. the type of the
variable is determined by your selection in the Variable Type combo box. If you choose Control from the
Category combo box, the Variable Type will be a class such as CEdit that wraps the functionality of the
control. For this exercise, choose Value from the Category combo box and CString from the Variable Type
combo box. click OK to create the variable.
Figure 37: The Add Member Variable dialog box is where you define the new member variable
Once the variable m_EditBox is associated with the IDC_EDIT1 resource, if you highlight it in the Control IDs
list, you'll see a field labeled Maximum Characters appear at the bottom of the Member Variables tab of
ClassWizard. This allows you some control over the validation of the data entered into the control by limiting
the length of the text that a user is able to enter into the text box when the application is running. Enter a value
of 20 into this field and then click OK to close ClassWizard.
Now that the dialog resource and corresponding dialog class have been created, all that remains is to use the
dialog box in the application. In the next section, we'll see how to show the dialog box in response to a menu
item being selected.
Adding a Message Handler for an Event
Windows-based applications are message driven. This means that for every event such as a mouse-click or a
keystroke, Windows sends messages to the appropriate windows. The MFC framework processes Windows
messages, and in doing so provides some enhancements that make processing messages easier, more
maintainable, and better encapsulated.
The main application object of an MFC application is an instance of CWinApp. This class contains a member
function called Run, which is responsible for retrieving queued messages. The message loop in the Run
member function of class CWinApp retrieves queued messages generated by various events and dispatches
them to the appropriate window. In an MFC application, a dedicated handler function processes each separate
message. Such message handler functions are member functions of a class.
Each class in the MFC framework that is able to receive messages has a message map. Message maps are used
to connect messages and commands to their appropriate handler functions. All classes derived from the
CCmdTarget base class can have message maps. When such a class receives a message, it searches its message
map for an appropriate handler. If it finds one, it calls it; otherwise, it will probably route the message to
another command target.
After generating a new application using the MFC AppWizard, you'll find some message maps already defined
for you in the command target classes which may look something like the following listing:
BEGIN_MESSAGE_MAP(CMFCWizApp, CWinApp)
//{{AFX_MSG_MAP(CMFCWizApp)
ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code!
//}}AFX_MSG_MAP
// Standard file based document commands
ON_COMMAND(ID_FILE_NEW, CWinApp::OnFileNew)
ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)
// Standard print setup command
ON_COMMAND(ID_FILE_PRINT_SETUP, CWinApp::OnFilePrintSetup)
END_MESSAGE_MAP()
The message map consists of several macros. Two macros in particular, BEGIN_MESSAGE_MAP and
END_MESSAGE_MAP, define where the message map starts and ends. There are many other macros such as
ON_COMMAND that make up the content of the message map. You'll also notice comments in the message
map that include tags such as AFX_MSG_MAP. These comments are used by ClassWizard to determine which
message map entries it is managing.
On the Job: You'll rarely, if ever, need to edit the message map entries between the ClassWizard
AFX_MSG_MAP tags. In fact, doing so could prevent ClassWizard from being able to read the message map
at all. Many a developer has experienced grief while attempting to bypass ClassWizard and edit these entries
directly.
Your implementation of a message handler function is your opportunity to respond to the message in whatever
way is appropriate for your application. ClassWizard assists by creating the stubs of the message handler
functions for you. It also allows you to logically navigate within your source code by jumping straight to the
appropriate handler for various user interface elements such as menu items.
In working with the MFC framework, you'll find that ClassWizard greatly simplifies the task of managing
numerous handlers for Windows messages. Changes you make in ClassWizard affect your source files in the
following ways:
Message map entries are written to connect the handler function to the message.
A message handler function is declared as a member of the class.
A stub is created for the handler function where you can write your code to handle the message.
Continuing with the dialog box exercise that we created in the previous section on adding member variables,
we'll create a menu item that, when selected, will show the dialog box. To start off, open the project workspace
from the previous exercise. The first thing we need to do is to add a menu item that will be used to show the
dialog box. To display the menu resource editor, go to the ResourceView tab of the project workspace and
expand the Menu folder. double-click the IDR_MAINFRAME resource. When the menu editor is open, use
your mouse to click the View menu item and then double-click the blank menu item in your view menu's
drop-down menu. When the Menu Item Properties dialog box is displayed for the new menu item, assign it an
ID of ID_VIEW_TEST_DIALOG. enter the caption as Test&Dialog, and in the prompt field enter Display
the Test Dialog. When you are done, the Menu Item Properties dialog box should resemble Figure 4-38.
Figure 38: Use the Menu Item Properties dialog box to select the properties of a new menu item
After closing the Properties dialog box for this new menu item, you will see it displayed in the menu editor.
Right-click it in the menu editor and select ClassWizard from the context menu. When ClassWizard is
displayed, go to the Message Maps tab and in the Class Name combo box, select the class that is derived from
CWinApp in your application (if you selected the AppWizard defaults when creating your project this will be
the class with a name ending in App). Now select ID_VIEW_TEST_DIALOG from the Object IDs list box.
This list box shows all of the objects in the current class that are able to generate messages. The list box labeled
Messages shows the messages that the selected object can handle and any MFC virtual functions that can be
overridden. If a message in this list already has a handler function associated with it, the message will be
displayed in bold. For the ID_VIEW_TEST_DIALOG menu item, select the message called COMMAND. The
ClassWizard should look like Figure 4-39.
Figure 39: The Message Maps tab of ClassWizard is where you can create handler functions
Now click the Add Function button to display the Add Member Function dialog box, as shown in Figure 4-40.
Accept the default function name of OnViewTestDialog and click OK.
Figure 40: The Add Member Function dialog box suggests a name for the new member function
when you click the Edit Code button, ClassWizard will close and you'll be taken to the source code editor in
the function stub that has been created for you. Complete the implementation of the function so that it is the
same as the following listing:
void CMFCWizApp::OnViewTestDialog()
{
CTestDialog testDlg;
testDlg.DoModal();
}
Now in order for the compiler to recognize an object of type CTestDialog, you must include the header file for
the dialog class in the header file of the class to which this handler function belongs. Go to your
CwinApp-derived classes header file by selecting the ClassView tab in the project workspace and
double-clicking the name of the appropriate class (as previously explained, it will probably be the class with a
name ending in App). When the appropriate header file is displayed, go to the top of the file and type the
following line of code after any other #include statements that appear there: #include "TestDialog.h".
You'll now be able to recompile and run the application by selecting Build and then Execute from the Build
menu. When the application runs, you'll be able to go to the View menu of your application and select Test
Dialog and you should see the dialog box modally displayed as in Figure 4-41.
Figure 41: The Test Dialog has been launched by the message handler function that ClassWizard set up
The Test Dialog doesn't do anything at the moment, so to finish the exercise we'll add a message handler
member function to the CTestDialog class. This message handler function responds to the user clicking OK in
the dialog box and displays any text that the user may have entered in the Edit Box. Perform the following
steps to add a message handler function for the OK button in the CTestDialog class:
1. Open ClassWizard and go to the Message Maps tab.
2. Select CTestDialog from the Class Name combo box.
3. Select IDOK from the Object IDs list.
4. Select BN_CLICKED from the Messages list.
5. Click the Add Function button and accept the default function name, OnOK, in the Add Member
Function dialog box by clicking OK.
6. Back in the Message Maps tab of ClassWizard, click the Edit Code button. You'll be taken to the message
handler function stub in the TestDialog.cpp file.
7. Edit the implementation of the function so that it resembles the following listing:
void CTestDialog::OnOK()
{
// TODO: Add extra validation here
CDialog::OnOK();
AfxMessageBox(m_EditBox);
}
Notice that this function calls the base classes implementation of OnOK, which in turn calls DoDataExchange.
The DoDataExchange function performs the DDX for this CDialog-derived class so that when
AfxMessageBox is called, the m_EditBox member variable will contain the value that had been entered in our
dialog box's Edit Box with the resource ID IDC_EDIT1.
You should now be able to recompile and execute your application again. This time when you display Test
Dialog and enter something into its edit box, if you click OK to dismiss the dialog box you'll see a message box
containing the text that you entered, just like in Figure 4-42.
Figure 42: A message box from the message handler of our dialog box's OK button
From the Classroom
Enhancing User Interface Navigation Coding through Dynamic Menus
In this chapter, you were introduced to menus and you learned how to define menus at design-time using the
resource editor. When developing an intuitive, user-friendly interface it is sometimes desirable to change the
menu items that the user sees based on the activity that the user is currently performing within the application.
In order to make your menus context-sensitive, it may be necessary to implement dynamic menus. We will
discuss the first step in creating a dynamic menu: consolidating handlers into a command range.
When adding and removing menu items while your application is running, you will benefit from learning how
to consolidate handlers into a command range. When implementing command handlers for your menu items,
you may find that many command handlers are performing the same, or very similar, functions. Instead of
writing individual command handlers for each menu item, a command range can be used to map several menu
items to a range of messages.
To consolidate command handlers, first determine the maximum number of new message entries, and add
symbolic constants in the resource table for each message entry. To do this, open the Resource Symbols dialog
box from the view menu, and select New. In the New Symbol dialog box, specify a name and a value for the
menu item. Repeat this for each item that you want to include in the range. Be sure to use consecutive numbers
greater than 33,000 for the resource symbol values. Using numbers greater than 33,000 avoids conflicts with
any predefined or existing messages.
Next, add an ON_COMMAND_RANGE entry, an option not available through the ClassWizard, to the
message map of the class that you want to receive the commands from the dynamic menu. Specify the first and
last numbers of the range that you entered in the resource symbols table as the first and second arguments of
the ON_COMMAND_RANGE macro, for example: ON_COMMAND_RANGE( ID_VIEW_ITEM1,
ID_VIEW_ITEM4, OnNewItems).
you will need to add an entry to the class's header file in the DECLARE_MESSAGE_MAP section, such as the
following example:
afx_msg void onNewItems( UINT nID );
To complete the process of adding menu items dynamically, you will need to add entries to the string table to
store your menu captions, write the code that adds your menu items, write the code to accept the commands
generated by the added menus, and add an entry to the header file for the class. When designing your
application's user interface, start by utilizing the code generated by the MFC AppWizard and the ClassWizard,
then add some "bells and whistles", such as context-sensitive menus, to make your interface professional and
polished.
This chapter has demonstrated the tools available in Visual C++ that aid the developer in creating the visual
elements of an application. We looked at how two of Developer Studio's most significant wizards, AppWizard
and ClassWizard can make it easier to develop Windows-based applications.
You've learned how to create and use MFC toolbars and status bars in your applications, as well as how to use
the various resource editors available in the Visual C++ environment. These resource editors assist you in
creating common Windows user interface elements.
We used AppWizard to create a new MFC application and then learned how to map messages to member
functions through ClassWizard. We also examined how ClassWizard is used to create member variables in a
dialog class that are connected to controls in a dialog resource.
Two-Minute Drill
One of the biggest challenges in designing and implementing a desktop application comes in the creation
of an effective user interface. The design of your application's interface can affect how a user perceives your
software more than any other factor.
Careful planning is required to ensure that the user interface exposes all the functionality of your
application while being intuitive and simple enough to allow the end user to quickly learn the application.
A toolbar is a special organizational visual element that can manage sets of other controls such as buttons,
button separators, and combo boxes. The primary role of toolbars in desktop applications is to provide quick
access to commonly-used functions.
Toolbars are usually positioned at the top of the client area of a main application window. Often,
however, toolbars are designed to be dockable, whereby the user can drag and place them on any border of the
application's top-level window or leave them in their own modeless window at any location on the screen.
All of the buttons of a toolbar resource are actually stored in a single bitmap. In an MFC project, the
bitmap for the initial AppWizard-generated toolbar is stored in the project's res subdirectory with the name
Toolbar.bmp.
Often you'll want to add text to your toolbar buttons in the same way Internet Explorer has text captions
for its toolbar buttons. Unfortunately, the toolbar editor doesn't provide any support for this, so you'll need to
use the SetButtonText function from within your code.
Toolbars also include ToolTips, which are small modeless windows that are briefly displayed when the
mouse lingers over a button for a certain interval. ToolTips are used to proactively give the user some feedback
about the purpose of a button.
Status bars give your application a place to display messages and useful information to the user without
interrupting the user. They are normally displayed at the bottom of a window and they consist of several panes,
which can include indicators and a message line.
AppWizard helps you generate the basic source files for a variety of different types of Windows-based
programs, allowing you to get down to the task of creating your application. The extensive amounts of
AppWizard-generated code handles many routine programming tasks, freeing the developer to concentrate on
implementing program functionality.
The final step of the MFC AppWizard involves reviewing and confirming the names, filenames, and base
classes of the classes that AppWizard will generate.
By default, AppWizard creates names for your application classes and files based on an abbreviation of
your project name. The majority of the time, you won't want to change the default names.
A Windows-based desktop application makes use of resources defined in a resource file, which is simply
a text file with the extension .RC. A Windows resource file contains a script with various statements that define
resources.
When a new resource is added to your project, it is automatically given a unique name. For example, a
new dialog box resource may be given the name IDD_DIALOG1, then the next dialog box resource added to
the project will be called IDD_DIALOG2. It is common convention, however, to change the generated name to
one that more accurately reflects the purpose of the particular resource in the context of your application.
To associate a menu item with a keyboard combination, simply assign the same resource identifier to
both the menu item and the relevant entry in the accelerator table. It's often appropriate to edit the menu item's
caption to show the name of the accelerator, as this isn't done automatically.
At some stage in the development process, it is necessary to hook-up the user interface objects to the core
functionality of the application. Visual C++ provides a reliable framework within which to achieve this. The
principle that tool Visual C++ provides to you to perform these tasks is ClassWizard.
The mechanism of mapping a dialog control to a dialog class member variable is called Dialog Data
Exchange (DDX). DDX eliminates the need for you to transfer data between the control and its corresponding
member variable yourself.
Windows-based applications are message driven. This means that for every event such as a mouse-click
or a keystroke, Windows sends messages to the appropriate windows.
Each class in the MFC framework that is able to receive messages has a message map. Message maps are
used to connect messages and commands to their appropriate handler functions.

Chapter 5: Creating the User Interface
Creating a Dialog Box. 2
Using the Dialog Editor 2
Creating Dialog Box Classes and Members Using ClassWizard. 7
Property Sheets Using ClassWizard. 12
Using the CFormView Class. 14
DDV.. 17
Status Bars. 27
Tool Tips. 28
Context-Sensitive Help. 28
Linking to a Web Page Containing Help Files. 31
Exception Handling. 32
Determining How to Handle an Error 34
Two-Minute Drill 37
Creating Data Input Forms and Dialog Boxes
Validating User Input
Process User Input Using Dialog Data Exchange (DDX)
Storing and Retrieving Personalized User Settings from the Registry
Implementing Online User Assistance in an Application
Error Handling
Creating Data Input Forms and Dialog Boxes
Most desktop programs written in Visual C++ provide for user input through some kind of form or dialog box. Using Visual
C++ with Microsoft Foundation Classes (MFC), you have several options for creating these data input windows: you can
create a form that adheres to the document/view architecture by deriving a class from CFormView; you can create a modal or
modeless dialog box from a class derived from CDialog; or you can create a tabbed dialog box, known as a property sheet,
from a class derived from CPropertySheet.
Creating a Dialog Box
The steps to creating a dialog box are as follows:
1. Insert a new dialog template.
2. Edit the dialog template using the Dialog editor.
3. Use ClassWizard to associate the dialog template with a C++ class derived from one of the MFC classes.
4. Use the class within the application.
Using the Dialog Editor
The Visual C++ integrated development environment (IDE) provides a Dialog editor for editing dialog templates. You will
use the Dialog editor to create and modify the resource templates that describe how dialog boxes will appear and how
New Page 7
controls will be laid out on those dialog boxes. In the following section you will see how to add a new dialog template to
your project and the role of the Dialog editor in creating your user input form resource templates.
Inserting a New Dialog Template
In order to insert a new dialog template into a project, follow these steps:
1. Select the Resource View.
2. Right-click Project Name Resources, select Insert, select Dialog, and click New; a new template will appear in the
tree under the Dialog folder with an ID similar to IDD_DIALOG1.
3. Right-click the new dialog ID and select Properties; you can modify the ID to something more meaningful, such as
IDD_CONTACT_DETAILS.
Editing a Dialog Template Using the Dialog Editor
Each of the types of user interface forms and dialog boxes is based upon one or more dialog templates. A dialog template
specifies which controls (such as list boxes or option buttons) will be contained on the dialog box, and how they will be laid
out. The dialog template also contains a number of different styles that determine how a dialog box should be displayed on
the screen.
It is possible to create dialog templates manually using a text editor; however, this would be an extremely tedious operation
involving a great deal of trial and error. To make the Visual C++ developers job easier, the Dialog editor has been provided
to allow drag and drop creation of dialog templates. It provides for WYSIWYG, or what you see is what you get editing of
the template, along with property sheets for setting the general properties, such as dialog box size and the font to be used, as
well as all of the associated styles, such as border type.
The Dialog editor is displayed when a Visual C++ workspace is in Resource View, and a dialog template has been selected.
Figure 5-1 shows the Visual C++ IDE when the dialog template with the ID of IDD_DIALOGTEST_DIALOG has been
selected in the Resource View. You can see the WYSIWYG view of the dialog template in the rightmost pane, and to the
right of that is the Controls toolbar. At the bottom of the IDE you can see the Dialog toolbar. Remember that many windows
and toolbars in the Visual C++ IDE can be moved around, docked or undocked, hidden or displayed, and that your own setup
may appear different from the figure. Note that toolbars are selected and cleared from the Toolbars tab of the Tools |
Customize property sheet.
Figure 1: The Visual C++ IDE showing the Dialog editor, the Controls toolbar, and the Dialog toolbar
New Page 7
The Controls toolbar provides a selection of controls that may be dragged onto the dialog template. Simply click a control,
such as a button, and drag it onto the template. The control will initially appear with a default size and with a number of
default properties; you can then resize the control and set its properties. Alternatively, you can select a control from the
Controls toolbar by a single click and then place and size it in a single step. Click the dialog template where one corner of the
control will appear and then while holding down the mouse button, drag the mouse to where the diagonally opposite corner
of the control is to be positioned. By default, the Controls toolbar provides the set of controls shown in Table 5-1.
Control Function
Picture May contain various types of images including bitmaps and icons
Static text Places read-only text as a label
Edit box Input field for alphanumeric text
Group box Provides a heading and grouped outline to contain other controls
Button Standard pushbutton-type control
Check box Allows on and off selection
Option button Option buttons, also called radio buttons, are buttons that are usually grouped
together; when one button is selected, the others in the group are cleared.
Combo box A combination of a list box and an edit box
List box Provides for selection of one or more items in a list
Horizontal scroll bar A narrow bar with a button at each end and a thumb or slider in between for
manual scrolling of an associated window
Vertical scroll bar A vertical version of the horizontal scroll bar
Spin A pair of up and down arrow buttons; usually used to increment or decrement
values in an associated control
Progress indicator A control used to provide feedback of progress over time
Slider Similar to slider-type controls found on electronic equipment
Hot key Used for enabling user-configured hot key functionality in an application
List control Similar to the rightmost pane of Windows Explorer; allows for different
views of information including multiple columns
Tree control Similar to the leftmost pane of Windows Explorer; presents information in an
hierarchical format
Tab control Provides a row of tabs for selection between multiple forms
Animate Houses Audio-Video Interleaved (AVI) files to display animations without
audio
Rich Edit Enables the display and editing of Rich Text Format (RTF) text
Date Time Picker Used to allow user input of dates and times
Month Calendar Calendar control
IP address Allows user input of Internet Protocol (IP) addresses in dotted decimal
notation
Custom control Allows the use of custom-built controls; it is now recommended to use
ActiveX controls instead
Extended Combo box Combo box control with support for image lists
Additional ActiveX Controls As ActiveX controls are added to a project, the Controls toolbar will be
extended with icons for the additional controls. As covered in a previous
chapter, you can add an ActiveX control to a project by right-clicking a
dialog template and selecting Insert ActiveX Control... from the context
menu.
Table 1: Controls Provided by the Controls Toolbar
The Dialog toolbar, which defaults to being displayed at the bottom of the IDE when a dialog template is being edited,
provides some very useful functionality for testing your dialog box and for sizing and positioning your controls. There is a
Test tool that displays a test version of the dialog box just as it will appear when it is used in your application. The tools for
alignment and resizing of controls work on a group of controls; press the shift key and progressively click each controlthe
last control selected becomes the Dominant control and the other controls selected will be resized or aligned to that controls
size or position.
Creating Dialog Box Classes and Members Using
ClassWizard
Once you have created a dialog template you must create an appropriate C++ class and associate the template with the class
before it can be used in your application. In this section we will cover how to use ClassWizard to perform these steps.
Associating the Dialog Template with a C++ Class
A dialog template is purely a resource template; in order for it to be used in your application, it must be associated with, or
bound to, a C++ class. ClassWizard manages the creation of these classes and allows you to select the appropriate MFC class
to use as a base class.
New Page 7
Exam Watch: Be sure that you understand the distinction between dialog templates and the C++ classes that they are
associated with. A dialog template purely describes how the dialog box will look, how controls will be laid out on the dialog
box, and so on, whereas a C++ class provides the actual code that gives the dialog box functionality to be displayed, respond
to messages, validate user input and the like.
ClassWizard can be used to create new classes that are derived from a wide selection of base classes. Many of these base
classes, for example CAsyncSocket, are not designed for creating user input forms and cannot be associated with dialog
templates; those that can are CDialog, CFormView, CPropertyPage, and CRecordView.
When creating dialog boxes, you will derive your classes from CDialog, which is the MFC-provided base class for dialog
boxes. When you create a new class using ClassWizard you need to specify a class name; when you type a class name
ClassWizard will autogenerate a filename for the C++ classyou should generally accept this name although you may
override it. ClassWizard also provides some options for Automation, which is the facility for exposing control of the dialog
box to external applications; automation is beyond the scope of this chapter.
Exercise 5-1 Associating a New Class with a Dialog Template
1. Create a dialog template as described previously.
2. In the rightmost pane of Resource View, right-click the dialog template and select ClassWizard.
3. For a new template, a message box will appear titled Adding a class; select Create a new class and press OK. A dialog
box will be displayed similar to Figure 5-2.
Figure 2: Options for creating a new class associated with a dialog template
4. Assign a meaningful name to the class, for example, CContactDetailsDlg, and select a base class from the list. Dialog
templates are usually associated with classes derived from CDialog, CPropertySheet, or CFormView.
On The Job: It has become customary for C++ programmers to name classes using a capital C as the first letter. If you follow
conventions such as these, your code will be much easier for other people to comprehend and maintain.
5. Click OK on the main ClassWizard form.
Using a Dialog Class in an Application
A dialog box can be displayed in one of two ways; either modal or modeless. If a dialog box is modal, it must be responded
to and dismissed before the user can interact with any other part of the application. Modeless dialog boxes, on the other hand,
do not cause the rest of the application to be disabled, and any number of modeless dialog boxes may be displayed by an
application at the same time.
For an example of a modal dialog box, take a look at the Options property sheet for Microsoft Visual C++, found under
Tools | Options. While this property sheet is being displayed, the rest of the Visual C++ IDE user interface is disabled; you
cannot perform any mouse or keyboard interaction with it until you have dismissed the Options property sheet. The Options
property sheet is shown in Figure 5-3.
New Page 7
Figure 3: The Visual C++ Options property sheet as an example of a modal dialog box
The floating toolbars in Visual C++ are an example of modeless windows; more than one of them can be present at any one
time, and they do not cause the application to be disabled while they are displayed. Figure 5-4 shows the Visual C++ IDE
with several floating toolbars.
Figure 4: Floating toolbars are an example of modeless windows
The life cycles of modal and modeless dialog boxes are slightly different. To create and display a modal dialog box, you
should perform the following steps:
1. Construct an instance of the dialog box class in your code, for instance:
CMyModalDlg dlgModal;
2. Call CDialog::DoModal(). This will not return until the dialog box is dismissed, when it will return the code passed to
EndDialog(). The default implementation of CDialog::OnOK() actually calls EndDialog() automatically, passing in a value
of IDOK, and similarly for OnCancel (which passes a value of IDCANCEL). So, unless you add any other buttons you do
not have to add any additional code to the dialog class for EndDialog() to be called:
int iResult;
iResult = dlgModal.DoModal();
3. When a button on the dialog box, such as the OK button, is pressed, the dialog box should call EndDialog(), and pass
the ID of the button as a parameter.
4. Interpret the return value from DoModal() to determine which button was pressed to dismiss the dialog box:
if (iResult == IDOK) {
// OK button was pressed
// Process the dialogs data
}
else {
// Dialog was canceled
New Page 7
// Ignore the data
}
5. Processing the data collected by the dialog box will be covered in the section on DDX, the dialog data exchange.
To create, display, and dismiss a modeless dialog box, you should perform the following steps:
1. Make sure your dialog class exposes a public constructor which includes a call to the CDialog::Create() method,
passing in the ID of the associated dialog template. As an example:
CMyModelessDlg::CMyModelessDlg(CWnd* pParent /*=NULL*/)
: CDialog(CMyModelessDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CModelessDlg)
// NOTE: the ClassWizard will add member initialization here
//}}AFX_DATA_INIT
Create(IDD_DIALOG1); /* Add this line to the ClassWizard-generated constructor */
}
2. Instantiate your dialog object, and if the Visible style was not set on the dialog template include a call to
ShowWindow():
CMyModelessDlg* pDlgModeless;
pDlgModeless = new CMyModelessDlg; // Constructor should call Create()
pDlgModeless->ShowWindow(SW_SHOW); // Make visible
3. Add methods to handle events from controls on the dialog box. A common control on a modeless dialog box would be
an Apply button; the button needs to perform some kind of action but the dialog box should remain visible. To implement
this you would add a button to the dialog template, say with an ID of IDC_APPLY, and then use ClassWizard to implement a
message map for the BN_CLICKED event to be mapped to a new member function:
void CModelessDlg::OnApply()
{
// TODO: Add your control notification handler code here
UpdateData(); /* this will read the contents of controls into mapped variablessee the section on DDX */
/* At this point you may wish to make calls back to the parent window object to save the data */
}
4. Ensure that when the dialog box is no longer required, the object is deleted. Believe it or not, the recommended method
is for a modeless dialog object to delete itself; override the PostNcDestroy() method and call delete this from within it. You
should also ensure that OnOK() and OnCancel() are overridden to call DestroyWindow()otherwise the dialog object will
disappear but persist in memory if the user presses Enter or Esc.
Property Sheets Using ClassWizard
A property sheet is a tabbed dialog box, which is really a collection of dialog boxes laid over the top of each other with each
one being selectable by a tab. For an example of a property sheet, take a look at ClassWizard itself.
You implement a property sheet by creating a number of objects. One object is instantiated from a class derived from
CPropertySheet; this class is not associated with any dialog template. Then for each dialog box that is to be included in the
property sheet, a class should be derived from CPropertyPage, and an object of that class added to the property sheet. You
will find some of the steps in creating a property sheet are similar to those involved in creating a dialog box:
1. In Resource View, insert one new dialog box for each page required in the property sheet.
2. Edit each of the dialog templates using Dialog editor. Note that each page of the property sheet does not have to be the
same size; the property sheet will size itself to accommodate the largest dialog template it contains. It is also important that
you set certain styles for the dialog templates, as described in the following table:
Caption Set to the text that is to appear on the tab for that page
Style Set to Child
Border Set to Thin
Title bar Should be selected
Disabled Should be selected
3. For each dialog template that you have created, right-click the template and select ClassWizard and then create a new
class with a base class of CPropertyPage to be associated with that particular dialog template.
4. Use ClassWizard to create a new class derived from CPropertySheet; this class will not be associated with any dialog
templates.
5. Construct a property sheet object in your code, for example:
CMyPropertySheet* pPropSheet;
pPropSheet = new CMyPropertySheet;
New Page 7
6. Construct objects for each of the property pages, for example:
CMyAddressDetailsPage pageAddrDetails;
CMyBillingDetailsPage pageBillingDetails;
CMyFinalPage pageFinal;
7. Add each of the property page objects to the property sheet:
pPropSheet->AddPage(&pageAddrDetails);
pPropSheet->AddPage(&pageBillingDetails);
pPropSheet->AddPage(&pageFinal);
8. The property sheet can now be displayed; either call DoModal() to display it as a modal property sheet, or Create() to
display it as a modeless property sheet.
9. Data is exchanged and validated using the normal DDX and dialog data validation (DDV) mechanisms as described
elsewhere in this chapter; just treat each property page object in the same way as you would one of a CDialog-derived class.
Using the CFormView Class
Sometimes when you are developing a desktop application in Visual C++, you may want to allow for user input through a
form that adheres to the document/view architecture rather than through a dialog box. The CFormView class provides the
functionality for associating a dialog template with a view class, and allows you to produce an application that combines
dialog-style user input with standard application user interface elements such as menus, toolbars, and status bars. An example
of an application which employs a CFormView-derived class is shown in Figure 5-5.
Figure 5: A simple example using a CFormView-derived class
The MFC document/view architecture was covered in Chapter 3. The CFormView base class takes advantage of this
architecture and extends CView to provide dialog-style functionality within either single-document interface (SDI) or
multiple-document interface (MDI) applications.
There are a few major differences between implementing a form view and implementing a dialog box; the most obvious ones
being that form views can not be modal, and the code to create and display a form view is very different from that used to
create and display a dialog box. Objects of the types derived from CdocTemplate, CSingleDocTemplate for SDI applications
and CMultiDocTemplate for MDI applications, are used to manage the relationships between documents, views, and frame
windows. It is through the use of these objects and the document/view architecture framework that form views are created
and displayed at runtime.
Exercise 5-2 Using the CFormView Class
1. Create a single-document interface (or multiple-document interface) application using the MFC AppWizard. You may
not wish to include MFC support for the Print and Print preview commands, unless you are willing to write custom printing
code. MFC does not provide functionality for printing CFormView views
2. Create a new dialog template using the Dialog editor. It is essential that the following properties are set for the dialog
template:
Style Child
Border None
Visible False
New Page 7
3. Right-click the dialog template, select ClassWizard, and select Create a new class.
4. In the Base class list box, select CFormView and assign the class a meaningful name.
5. Use the class within the application. The most straightforward way to do this in an SDI application is to modify the
InitInstance() method of the application class. This method constructs a new CSingleDocTemplate object; modify the third
parameter to your new CFormView-derived class name. Remember that in an MDI application you will be dealing with one
or more CMultiDocTemplate objects. The following example demonstrates this for an SDI application:
#include DetailsForm.h // Dont forget this!
...
CSingleDocTemplate* pDocTemplate;
pDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CTestFormDoc),
RUNTIME_CLASS(CMainFrame),
RUNTIME_CLASS(CDetailsForm)); // This is the new view class
6. Build and run the application.
Validating User Input
Visual C++ desktop applications, and any applications that allow some form of user input, must provide some form of
validation of the data. Visual C++ provides a mechanism known as dialog data validation, or DDV, which is configured
through the ClassWizard.
DDV
DDV, or dialog data validation, provides some fairly basic validation for controls that are mapped to either CString or
various numeric variable types. The validation works slightly differently for CString members than it does for the numeric
types.
When a control, such as an edit box, is mapped to a CString variable and that variable is selected in the list on the Member
variables tab of ClassWizard, an edit box labeled Maximum characters will be displayed. If an integer value is typed in this
field, DDV will be applied to the control. The control will limit the number of characters that may be typed into it; this
applies as the user is typing, and the user will be unable to exceed the maximum number of characters.
When a control, such as an edit box, is mapped to a numeric type, such as int, and that variable is selected in the list on the
Member variables tab of ClassWizard, two edit boxes will be displayed; one labeled Minimum value, and the other labeled
Maximum value. If values are typed in these fields, DDV will be applied to the control. However, in this case the validation
is not performed as a user is typing, but when the UpdateData() member of the dialog class is called. This is most commonly
called when a user has completed all data input to a dialog box and a button such as OK has been clicked. If UpdateData()
returns TRUE, the data has been validated correctly and it is safe to dismiss the dialog box. However, if a value has been
entered in a control which is below the minimum or exceeds the maximum, a message box will be displayed and focus will
be set to the offending control prior to UpdateData() returning FALSE. In this case, it is not safe to dismiss the dialog box.
ClassWizard creates DDV mappings within the source code of your dialog class. When you make changes to the DDV
configuration in ClassWizard these mappings are maintained within your source code; you should never make changes to
ClassWizard mappings directly in the code. An example of a ClassWizard data map that validates an edit box to a number
between 10 and 250 and another edit box to a string of maximum five characters looks like this:
void CDDVDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CDDVDlg)
DDX_Text(pDX, IDC_EDIT_NUMERIC, m_iNumeric);
DDV_MinMaxInt(pDX, m_iNumeric, 10, 250);
DDX_Text(pDX, IDC_EDIT_STRING, m_sString);
DDV_MaxChars(pDX, m_sString, 5);
//}}AFX_DATA_MAP
}
It should also be noted that the implementation of CDialog::OnOK() calls UpdateData(); therefore, if your dialog class makes
use of the base class implementation of OnOK(), it is not necessary to make any additional calls to take advantage of DDV.
The implementation of CDialog::OnOK() looks similar to this (with some additional debugging code):
void CDialog::OnOK()
{
if (!UpdateData(TRUE))
{
return;
}
EndDialog(IDOK);
}
New Page 7
Exercise 5-3 Adding Numeric and String DDV to a Dialog
In this exercise you will:
Create a dialog template using the Dialog editor
Create member variables associated with controls on the dialog box using ClassWizard
Validate both string and numeric input using DDV
Creating a Dialog Template Using the Dialog Editor
1. In the Visual C++ IDE, select File -> New, and select MFC AppWizard (exe) from the Projects tab to invoke the MFC
AppWizard.
2. Enter DDV as the project name, and click OK.
3. Select Dialog based as the application type, and click Next.
4. Clear the About box option, and click Next.
5. Click Finished, and the new project files will be created.
6. Select the Resource View, and select the dialog ID, IDD_DDV_DIALOG.
7. Resize the dialog template as desired, and add an edit box control. Right-click the edit box control, select Properties,
and change the control ID to IDC_EDIT_NUMERIC, as shown in Figure 5-6.
Figure 6: Modifying the control ID from the General tab of the control properties
8. Add a second edit box and change its control ID to IDC_EDIT_STRING.
9. Resize the edit box controls as desired, and add some static text controls. Your dialog template should now look
something like the one shown in Figure 5-7.
Figure 7: Use the Dialog editor to create this dialog template
Creating Member Variables Using ClassWizard
10. Right-click the dialog template, and select ClassWizard.
11. Because the dialog box was already created by the AppWizard, the class CDDVDlg should appear in the Class name
field on the Message maps tab of the ClassWizard.
12. Select the Member variables tab; you should see a list of controls: IDC_EDIT_NUMERIC, IDC_EDIT_STRING,
IDCANCEL, IDOK
13. Double-click IDC_EDIT_NUMERIC; the Add member variable dialog box will appear.
14. Type m_iNumeric for the Member variable name, select Value for the Category and int for the Variable type, and press
OK.
New Page 7
15. Double-click IDC_EDIT_STRING; the Add member variable dialog box will appear.
16. Type m_sString for the Member variable name, select Value for the Category and CString for the Variable type, and
press OK.
Validating String and Numeric Input Using DDV
17. Select IDC_EDIT_NUMERIC; the DDV parameter fields will appear at the bottom of the ClassWizard. Enter a
Minimum value and Maximum value as per Figure 5-8.
Figure 8: Set the DDV parameters using the ClassWizard
18. Select IDC_EDIT_STRING; the DDV parameter fields will appear at the bottom of the ClassWizard. Enter 5 for the
Maximum characters.
19. Press OK to dismiss the ClassWizard dialog box.
20. Build and run the application.
21. Observe that you cannot type more than five characters in the string edit box, and that upon pressing OK the numeric
edit box is validated for minimum and maximum values.
Process User Input Using Dialog Data Exchange (DDX)
MFC provides a very useful method of both initializing data and processing user input on dialog boxes; it is known as dialog
data exchange, or DDX. This is a mechanism that maps member variables to controls on dialog boxes. For example, I may
map an edit box on my dialog box to a CString variable in my code. I want the initial value of the variable to contain the text
Not Applicable so I set my variable to contain that text, and DDX transfers it to the edit box control when the dialog box is
initialized. Then when the dialog box is dismissed, the new text typed by the user is transferred back to my variable and I can
access it from code elsewhere in the application.
The mappings between controls and variables are created and maintained by ClassWizard.
Exercise 5-4 Mapping an Edit Box to a CString Variable
The following steps are involved in mapping an edit box to a CString variable:
1. As described previously, create an MFC application containing a dialog template and a class derived from CDialog that
is associated with the dialog template.
2. Ensure that the dialog template contains an edit box, with an ID such as IDC_EDIT_DDX.
3. Right-click the dialog template and select ClassWizard; you should be viewing the properties of your existing dialog
class. Figure 5-9 shows the ClassWizard Member variables tab.
New Page 7
Figure 9: Use the ClassWizard Member variables tab to view the properties of your existing dialog class
4. Double-click the Control ID for the edit box. You should see the Add member variable dialog box. Add a meaningful
variable name and select the CString type, as shown in Figure 5-10.
Figure 10: Adding a member variable using ClassWizard
5. Click OK on the Add member variable dialog box, and click OK to dismiss ClassWizard.
6. The actual DDX exchange of data is initiated by the CDialog::UpdateData() method; calling UpdateData(FALSE)
causes data to be transferred from member variables to controls, whereas calling UpdateData(TRUE) causes data to be
transferred from controls to member variables and performs any DDV validation. Note that if no parameter is passed to
UpdateData(), it will default to TRUE.
7. Edit the OnInitDialog() method of your dialog class to set the member variable to a default value:
BOOL CTestDDXDlg::OnInitDialog()
{
m_sAuthorizedBy = "Not Applicable";
CDialog::OnInitDialog(); /* This will call UpdateData() */
...
return TRUE;
}
8. Create and display a dialog object. Once the dialog box has been dismissed, read the value from the member variable
before the object has been destroyed:
New Page 7
CTestDDXDlg dlg;
int iRes;
CString sQuant;
iRes = dlg.DoModal();
if (iRes == IDOK) {
sAuth = dlg.m_sAuthorizedBy;
}
else {
// Dialog was canceled
sAuth = Not Applicable// Set a default value
}
Storing and Retrieving Personalized User Settings from the Registry
Often it is desirable to store application settings on a per-user basis; when a particular user logs onto a machine and runs an
application, they will find the settings restored to the same state as when they last used the application. This is achieved by
storing the settings in the HKEY_CURRENT_USER hive of the Registry; usually as values under the key
HKEY_CURRENT_USER\Software\CompanyName\ApplicationName\SectionName\.
MFC provides a very simple mechanism for reading and writing personalized user settings to and from the registry; several
member functions of the CWinApp class are provided to do just that. The steps to achieving this are as follows:
1. Create your MFC application using the MFC AppWizard.
2. Your application will contain a class derived from CWinApp, for example CMyProgramApp. In the InitInstance()
member of this class, there will be an AppWizard-generated line of code that calls SetRegistryKey() and passes in some
default text. Modify this line to set the name of your company:
SetRegistryKey(_T("ACME Software Company"));
3. Integer values can be read from the registry using CWinApp::GetProfileInt(), and string values can be read from the
registry using CWinApp::GetProfileString().The following code could be placed in the InitInstance() method of your
CWinApp-derived application class, after the call to SetRegistryKey(): The following code could be applied when a user
selected some new settings, such as in the handler for an Apply button on a property sheet:
// Restore the user's settings from the registry
int nHeight;
CString sMessage
nHeight = pMyApp->GetPRofileInt("Window Settings", "Height", 500); /* 500 is a default */
sMessage = pMyApp->GetPRofileString(("Window Settings", "Startup Message", "Hi"); /* "Hi" is a default */
Integer values can be written to the registry usingCWinApp::WriteProfileInt(), and string values can be written to the registry
using CWinApp::WriteProfileString(). The following code could be applied when a user selected some new settings, such as
in the handler for an Apply button on a property sheet:
int nHeight;
CString sMessage
...
// User selects a value of 600 for window height,
// and "Good Morning" for startup message
// Store these settings in the registry
pMyApp->WriteProfileInt("Window Settings", "Height", nHeight);
pMyApp->WriteProfileString("Window Settings", "Startup Message", sMessage);
Implementing Online User Assistance in an Application
In developing desktop applications, you will generally want to provide one or more forms of user assistance; Visual C++
provides several mechanisms for you to do this. Status bars can be used to provide feedback to users, tool tips can be
employed to pop up a concise piece of text explaining the function of a tool (a control or child window), and full-blown help
systems can be provided that use either WinHelp or Hypertext Markup Language (HTML) Help. It is also possible to link
from a WinHelp help system to a Web site that contains help files.
Status Bars
As covered in Chapter 4, status bars comprise a set of panes, each of which may display certain text that may be updated at
any time. An example of a status bar giving dynamic feedback to a user is shown in Figure 5-11; Internet Explorer provides
useful information in its status bar.
New Page 7
Figure 11: You can create status bars that provide dynamic feedback for user assistance
In order to change the text in a pane of a status bar, you use the SetText() method, passing in the text to be displayed, the
integer index of the pane to display it in, and a type. An example is:
myStatusBar.SetText(You may click Finish at any time, 0, SBT_NOBORDERS);
The following types are valid for the third parameter:
0 The text is drawn with a sunken look.
SBT_NOBORDERS The text is drawn without borders.
SBT_OWNERDRAW The text is drawn by the parent window.
SBT_POPOUT The text is drawn with a raised look.
Tool Tips
Tool tips are small boxes containing help text specific to a specific control or child window. As the mouse cursor pauses over
the tool the tool tip is displayed, giving the user potentially valuable information about the usage of the tool. As buttons with
only icons and without any textual description have become more popular, tool tips have become an essential device for a
user to learn how to use an application.
In Chapter 4 you saw how support for tool tips is included with MFC toolbar buttons. However, it is also possible to provide
tool tips for any other tools in your application. This is achieved by following these steps:
1. Construct an instance of a CToolTipCtrl object and call Create(), passing the parent window as a parameter:
CToolTipCtrl* pMyToolTipCtrl;
pMyToolTipCtrl->Create(pMyDialog);
2. Call AddTool() to register a tool with the tool tip control, so that the information stored in the tool tip is displayed when
the cursor is on the tool:
pMyToolTipCtrl->AddTool(pMyControl, This is my control!);
Context-Sensitive Help
Context-sensitive help comprises a set of hyperlinked help topics. Many of these topics can relate to a certain context within
an application; the context may be the top level of the application itself, the dialog box that the user is currently working
with, or maybe a particular control. The context-sensitivity comes in to play when the help for the particular part of the
application that the user is currently working with is displayed.
There are several ways for the user to access help from within your application:
F1 HelpThe user can press the F1 key from an active window, dialog box, or message box, or with a menu item or
toolbar button selected. This will invoke the appropriate Help topic relevant to the selected item. For menu items, help is
summoned for the item currently highlighted.
shift-f1 Help or Help modeHelp mode can be activated by pressing shift-f1, or clicking the Help toolbar button. In
New Page 7
Help mode, the mouse cursor changes to an arrow with a question mark and the user can click any window, dialog box,
message box, menu item, or toolbar button to activate specific help for that item. Help mode ends when either Esc is pressed,
Help is displayed, or the user switches to another application and back again.
Using the Help menuBy selecting a Help menu item, the user can activate the applications Help file. Figure 5-12
shows the result of selecting the Help topics menu item in an MFC application.
Figure 12: You can create context-sensitive Help in MFC applications
When you use the MFC AppWizard to create either an SDI or MDI application, you will be given the opportunity to add
context-sensitive help. In Step 4 of the AppWizard, select the check box labeled Context-sensitive Help. When you enable
this option, the AppWizard adds the following features to your application:
The main menu now includes a Help menu with several commands. Note that for an MDI application there will be
multiple copies of this menu; one for an application with no documents open, and one for each type of document that uses its
own menu structure.
Your CFrameWnd-derived class will contain several additional message-map entries which bind the f1 and shift-f1
commands to their respective command handlers. These are created by AppWizard and should not be modified. In a simple
SDI application these look as follows:
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
//{{AFX_MSG_MAP(CMainFrame)
// NOTEthe ClassWizard will add and remove mapping macros here.
// Do not edit what you see in these blocks of generated code !
ON_WM_CREATE()
//}}AFX_MSG_MAP
// Global help commands
ON_COMMAND(ID_HELP_FINDER, CFrameWnd::OnHelpFinder)
ON_COMMAND(ID_HELP, CFrameWnd::OnHelp)
ON_COMMAND(ID_CONTEXT_HELP, CFrameWnd::OnContextHelp)
ON_COMMAND(ID_DEFAULT_HELP, CFrameWnd::OnHelpFinder)
END_MESSAGE_MAP()
The base class CWinApp provides the WinHelp() method, which is responsible for invoking the Windows Help
program, WINHELP.EXE.
AppWizard also adds several skeleton .RTF files that contain Help entries for the common elements of the Windows
user interface, such as the File and Edit menus. You can edit these files to revise the supplied text and add your own
application-specific Help information. RTF files must be edited by an application that can edit the Rich Text Format;
Microsoft Word is such an application.
A mechanism and tool for mapping resource and command IDs in your application to Help contexts in Windows Help.
When you build your application, a tool called MakeHm is run to perform this mapping.
An .HPJ file is created by AppWizard, which serves as a Help project. This file will need to be recompiled whenever
New Page 7
you add new Help topics to your application.
Linking to a Web Page Containing Help Files
The emerging method of providing Help is HTML Help, which uses Internet Explorer functionality to display the Help.
HTML Help applications are compiled into a .CHM file. It is possible to link from a WinHelp topic to an HTML Help topic,
and it is also possible for the WinHelp topic to link to a .CHM file located on a Web site. To do this, you add a call to the
!execfile WinHelp macro to the link in the appropriate WinHelp topic:
!execfile(hh.exe, ms-its:http://www.mysite.com/MyHelpFile.chm::/MyTopic.htm)
Error Handling
No matter how much a programmer may believe otherwise, error conditions are to be expected in the use of any desktop
application, and the usefulness of an application will depend to a certain extent on how errors are handled. There are a couple
of methods of both raising and handling errors in a Visual C++ application; the most common methods are function return
values and C++ exceptions.
Exception Handling
Exceptions are error condition objects which are thrown by a function when an error condition is encountered. They are then
passed progressively back up the call stack until they are caught by some code that then handles the error, or else the
application will abort.
MFC provides two versions of exception handling; the MFC exception macros, which are provided for
backward-compatibility, and C++ exceptions, which are now the recommended mechanism. For the exam, you should
understand the C++ exception mechanism.
The base class for all MFC exceptions is CException; a number of other exception classes are derived from this, including
CMemoryException, COleException, and CInternetException. All of these classes include the following two methods:
GetErrorMessage() Retrieves the message describing an exception. This method takes as minimum
parameters a string buffer pointer and the size of the buffer.
ReportError() Reports an error message in a message box to the user; does not require any
parameters.
The steps for handling exceptions are as follows:
Any code that makes calls that may throw exceptions should be wrapped in a try block. As an example, the MFC file
class CFile constructor throws exceptions of type CFileException when error conditions are encountered:
CFile* pMyFile;
try
{
pMyFile = new CFile(C:\\Nonexistant File.txt, CFile::modeRead);
// This will throw an exception if the file does not exist
}
Follow the try block with one or more catch blocks for the appropriate exception types, or for CException to catch all
exceptions. The following code will display the message box as shown in Figure 5-13:
catch(CException* e)
{
e->ReportError(); // Displays a message box
e->Delete(); // Delete the exception when weve done with it
}
Figure 13: Message box produced by CException::ReportError()
If you wish to handle different kinds of exceptions selectively, use multiple catch blocks. Control will be passed to the
first catch block that matches the type of the exception.
catch(CFileException* fileException)
{
// Handle a file exception
New Page 7
fileException->Delete();
}
catch(CDaoException* daoException)
{
// Handle a DAO exception
daoException->Delete();
}
catch(CException* e)
{
// Default catch for all other exceptions
e->Delete();
}
Exam Watch: Make sure you are confident with multiple catch blocks for the exam. You should understand that a catch
block will catch any exceptions of the specified type, or of any type derived from that class. So catching exceptions of type
CFileException will catch any exception class derived from CFileException, and catching exceptions of type CException
will catch all exceptions, as CException is at the top of the exception class hierarchy.
Handle the exception appropriately. In this example, you would consider prompting the user for a new filename to load,
or ask the user if they would like to create the file.
Appropriate Deletion of Exception Objects
It is always safer to use the Delete() member of the CException class and its derived classes rather than the C++ delete
statement, as the exception object may not always have been created using new and so may not be on the heapin this case
the delete would fail. Also note that if your catch block re-throws the same exception object, you should not delete that
object; it should be deleted by the catch block that catches it further up the chain.
Determining How to Handle an Error
Whether errors have been thrown and caught as exceptions or passed back to the caller as return values, they need to be
handled in a fashion appropriate to the situation. There is no point in detecting that an error has occurred in the opening of a
file, only to go on and attempt to write to a file. Likewise, your applications users will not be very impressed if the
application aborts due to a trivial and noncritical error.
It is impossible to speculate about all of the different error scenarios that may arise in the applications you will build;
however, there are some basic rules to keep in mind:
Determine which error conditions users should be notified about.
Ensure the application cannot get into an inconsistent state.
Fatal errors, or errors from which you cannot recover, should cause the program to abort gracefully. A message box
should be displayed to inform users, and if possible any data should be saved prior to exit.
These rules on error handling are illustrated by some scenarios.
A user wishes to save a file to a pre-existing filename. Inform the user that the file exists and prompt them as to
whether they wish to overwrite the file.
A CFile object throws an exception during construction. Ensure that the program cannot go on to attempt to use
that object.
A fatal CMemoryException exception occurs. Inform the user of the reason that the application must
terminate and attempt to save data before exiting.
From the Classroom
Exploring exception handling strategy
With all of the time and effort you put into programming software's desired functionality, it is hard to swallow the fact that
about 30 percent of your final code will exist to handle undesired functionality, or error conditions. Considering the large
portion of code involved, the need for a planned approach to error handling is evident. There are several factors to consider
when constructing your error handling/recovery strategy.
Since exceptions do not have to be handled by the function in which they originate, one factor is simply deciding where the
exception will be handled. When an exception is thrown, the call stack is searched for the first handler with an argument that
matches the type of the exception. Let's walk through the steps that occur when a block of code within a try block executes,
so we can understand the stack unwinding process better.
The try block is entered as a part of the normal flow of execution in the application. Many functions can be called within a
try block, and these functions may throw the same or different types of exceptions. However, only one exception at a time
can be handled. If every function within the try block executes normally, the program will skip over the catch block(s)
following the try block, and continue executing.
New Page 7
If one of the function calls within the try block throws an exception, the exception will then search through the call stack for
a catch block that can handle it. First, the catch blocks following the try block will be searched, in order, for one with an
argument that matches the type of exception thrown. If no match is found, the exception will be thrown to the try block
encompassing the try block where the error occurred. That try block will then search through its catch blocks for a suitable
handler, and if a match is not found, the exception will be thrown to the try block encompassing it. This process continues
until the exception is either handled, or there are no more encompassing try blocks to which the exception can be thrown. If
the exception reaches this level, the process where the exception occurred will be aborted.
Once you decide where to handle an exception, the next consideration is deciding what code to put in the exception handler.
Besides sending error messages to the user, or reporting the error to an error tracking system, you need to look carefully at
what is skipped after an exception is thrown. It is very important to free allocated memory and close any open files. Using
the built-in features of the C++ language, the MFC Exception Classes, and a well thought-out error handling strategy, you
will be able to build a robust application that gracefully handles the majority of exceptions that can, and will, occur.
Data input forms and dialog boxes are created by editing dialog templates with the Dialog editor, and then using ClassWizard
to create classes derived from CDialog, CFormView, and CPropertySheet or CPropertyPage. ClassWizard can then be used
to configure dialog data validation, or DDV, as well as dialog data transfer, or DDX.
Personalized user settings for an application should be stored in the Registry under the HKEY_CURRENT_USER hive.
MFC provides facilities for reading and writing string and integer values to the Registry using member functions of the
CWinApp class.
Online user assistance can take a number of forms, including status bars, tool tips, context-sensitive WinHelp Help, and
HTML Help. Context-sensitive Help can be added to an application by choosing a setting in the MFC AppWizard. It is also
possible to link from a WinHelp topic to compiled HTML Help stored on a Web site.
Error handling is of great importance in a desktop application. There are several methods of passing errors back to calling
functions, including C++ exception handling. Depending upon the type of error, the application developer must decide the
appropriate method of handling it.
Two-Minute Drill
Using Visual C++ with Microsoft Foundation Classes (MFC), you have several options for creating these data input
windows: you can create a form that adheres to the document/view architecture by deriving a class from CFormView;
you can create a modal or modeless dialog box from a class derived from CDialog; or you can create a tabbed dialog
box, known as a property sheet, from a class derived from CPropertySheet.
The Visual C++ integrated development environment (IDE) provides a Dialog editor for editing dialog templates.
To make the Visual C++ developers job easier, the Dialog editor has been provided to allow drag and drop creation
of dialog templates. It provides for WYSIWYG, or what you see is what you get editing of the template, along with
property sheets for setting the general properties, such as dialog box size and the font to be used, as well as all of the
associated styles, such as border type.
Once you have created a dialog template you must create an appropriate C++ class and associate the template with
the class before it can be used in your application.
Be sure that you understand the distinction between dialog templates and the C++ classes that they are associated
with. A dialog template purely describes how the dialog box will look, how controls will be laid out on the dialog
box, and so on, whereas a C++ class provides the actual code that gives the dialog box functionality to be displayed,
respond to messages, validate user input and the like.
It has become customary for C++ programmers to name classes using a capital C as the first letter. If you follow
conventions such as these, your code will be much easier for other people to comprehend and maintain.
A property sheet is a tabbed dialog box, which is really a collection of dialog boxes laid over the top of each other
with each one being selectable by a tab.
The CFormView class provides the functionality for associating a dialog template with a view class, and allows you
to produce an application that combines dialog-style user input with standard application user interface elements such
as menus, toolbars, and status bars.
Visual C++ provides a mechanism known as dialog data validation, or DDV, which is configured through the
ClassWizard.
DDV, or dialog data validation, provides some fairly basic validation for controls that are mapped to either CString
or various numeric variable types.
Status bars comprise a set of panes, each of which may display certain text that may be updated at any time. In order
to change the text in a pane of a status bar, you use the SetText() method, passing in the text to be displayed, the
integer index of the pane to display it in, and a type.
Tool tips are small boxes containing help text specific to a specific control or child window.
The context-sensitivity comes in to play when the help for the particular part of the application that the user is
currently working with is displayed.
The emerging method of providing Help is HTML Help, which uses Internet Explorer functionality to display the
Help.
Exceptions are error condition objects which are thrown by a function when an error condition is encountered. They
are then passed progressively back up the call stack until they are caught by some code that then handles the error, or
else the application will abort.
New Page 7
Make sure you are confident with multiple catch blocks for the exam. You should understand that a catch block will
catch any exceptions of the specified type, or of any type derived from that class. So catching exceptions of type
CFileException will catch any exception class derived from CFileException, and catching exceptions of type
CException will catch all exceptions, as CException is at the top of the exception class hierarchy.
Whether errors have been thrown and caught as exceptions or passed back to the caller as return values, they need to
be handled in a fashion appropriate to the situation. There is no point in detecting that an error has occurred in the
opening of a file, only to go on and attempt to write to a file.
Data input forms and dialog boxes are created by editing dialog templates with the Dialog editor, and then using
ClassWizard to create classes derived from CDialog, CFormView, and CPropertySheet or CPropertyPage.
ClassWizard can then be used to configure dialog data validation, or DDV, as well as dialog data transfer, or DDX.
New Page 7

Chapter 6: Implementing ActiveX Controls
Inserting a Control using Component Gallery. 3
ActiveX Control Properties. 8
Handling an Event from an ActiveX User Interface Control 12
Dynamically Creating an ActiveX User Interface Control 23
ISAPI Server Extensions. 33
ISAPI Filters. 33
Advantages of Using ISAPI DLLs. 34
Using the MFC AppWizard to create an ISAPI DLL. 35
Creating Secondary Threads. 48
Downloading ActiveX User Interface Controls. 50
Two-Minute Drill 56
Using an ActiveX User Interface Control
Using the Internet Server API
Incorporating Dynamic HTML Scriptlets
Invoking a COM Component
Adding Asynchronous Processing
Using an Active Document
In this chapter, well discuss Microsofts ActiveX technology. ActiveX is a set of technologies that enables software
components to interact with each other in a networked environment, regardless of the language in which they were
created. Using it, you can build real business applications for the Internet and intranets that run across multiple
platforms.
An ActiveX component is a unit of executable code, such as an .exe, a .dll, or an .ocx file, that follows the ActiveX
specification for providing objects. ActiveX technology allows programmers to assemble these reusable software
components into applications and services. Using ActiveX, you can create controls, documents, and components that
run on desktops or the Internet. The functionality packaged within these building blocks can then be easily reused in
other Windows-based applications.
A number of vendors offer ActiveX components that you can purchase and use in your applications. These
components provide a wide variety of generic services, including numerical analysis, user interface elements, and
data management. You can also create your own components and combine these with generic components. Reusing
tested, standardized code in this way is called component software development.
ActiveX allows you to create compelling, interactive web sites using a variety of tools. Most importantly, ActiveX
provides interoperability between development tools, authoring tools, database products, and networking
technologies.
Well begin our exploration of ActiveX with a discussion of ActiveX controls and how you can utilize them in your
applications. Well also learn about the Internet Server Application Programming Interface (ISAPI). Finally, well
learn how to implement and use active documents.
Using an ActiveX User Interface Control
ActiveX controls are reusable objects that include visual elements and code. They are used in some type of
container, such as a form, an application, or a web page, to enable or enhance a users interaction with an
application. These controls have an .ocx file name extension.
ActiveX controls were originally called OLE controls. The first version of the OLE control specification appeared in
1994 and was intended to provide a generic, COM-based architecture for building reusable Microsoft Windows
controls. The specification was revised in 1996 and OLE controls were renamed ActiveX controls. At the same time,
Microsoft Internet Explorer gained the ability to host ActiveX controls in web pages. Thus, the primary purposes of
ActiveX controls are:
To provide developers with a way to easily incorporate existing software components into their applications
To provide web authors with a way to implement interactive web pages by providing a standard for
components that run on the client computer
You can easily utilize functionality provided by an ActiveX control in your Windows-based applications. In the
following section, well create a calendar application that uses Microsofts MonthView control.
Inserting a Control using Component Gallery
In this section well learn how to use an ActiveX control in a Microsoft Foundation Classes (MFC) application. In
order to do this, we must first create a new project which includes support for ActiveX controls.
Exercise 6-1 Creating the Calendar Project
1. Select the File | New menu entry. This opens the New dialog box, as shown in Figure 6-1. Click the Projects
tab and select MFC AppWizard (exe) as the project type. Type Calendar for the project name.
Figure 1: Select the MFC AppWizard to begin creating the Calendar project
2. Click the OK button in the New dialog box. This runs the MFC AppWizard, which asks a series of questions
before generating the project.
3. In the Step 1 dialog box, select Dialog based for the type of application you want to create, then click Next to
proceed to Step 2.
4. In the Step 2 dialog box, make sure that the check box for ActiveX Controls is selected, as shown in Figure
6-2. At this point, click Finish and AppWizard creates and opens the new project.
Figure 2: In Step 2 of the AppWizard, make sure support for ActiveX Controls is selected
Now that we have a project that supports ActiveX Controls, we can add to the project the control we wish to use. We
do this using the Components and Controls Gallery, as illustrated in the following exercise.
Exercise 6-2 Inserting an ActiveX Control into the Project
1. Open the Calendar project (if its not already open).
2. Select the Project | Add to Project | Components and Controls menu entry to open the Components and
Controls Gallery dialog box.
3. Open the Registered ActiveX Controls folder. This lists all of the ActiveX components that are registered on
your computer.
4. Select the Microsoft MonthView Control, version 6.0 as shown in Figure 6-3.
Figure 3: Use Component Gallery to insert an ActiveX control into our project
4. Click Insert to insert the control into your project.
5. When the message box appears, confirm that you wish to insert the control into the project by clicking the OK
button.
6. When the Confirm Classes dialog box appears, accept the default class and file names by clicking the OK
button.
7. Close the Components and Controls Gallery dialog box by clicking the Close button.
Exercise 6-3 Adding the ActiveX Control to a Dialog
Now that weve inserted the MonthView control into our project, we can use the dialog editor to place it on a dialog
box as we would a standard control item.
2. Switch to ResourceView and expand the Dialog folder.
3. Double-click the IDD_CALENDAR_DIALOG dialog box. This opens the application dialog for editing in the
dialog editor.
4. Delete the static text control created by AppWizard. This contains a note reminding you to place controls on
the dialog.
5. Because we have inserted the MonthView control into our project, an icon for it will appear on the dialog
editors Controls toolbar. Select this icon, as shown in Figure 6-4.
Figure 4: The dialog editor's Controls toolbar after adding the MonthView control to the project
6. Click in the dialog box at the location where you wish to place the control. Once youve placed it, you can
move and resize it as you would with any control.
7. Using the dialog editor, resize the dialog and arrange the controls as shown in Figure 6-5.
Figure 5: The actual date shown in the finished dialog box will vary depending on your systems date setting
8. Test the dialog box. It should show the current month with todays date circled in red. Try clicking some
different dates and using the buttons at the top of the MonthView control to view different months. You can return to
the current month at any time by clicking the Today text at the bottom of the control.
Thats all there is to using an ActiveX control in an MFC application!
This is very powerful, but what if you want to alter the default appearance or behavior of the control? Fortunately,
most ActiveX controls allow a great deal of flexibility by providing customizable properties.
ActiveX Control Properties
In the previous exercise, we placed the MonthView control in a dialog and then tested the dialog box. Because we
didnt manipulate any of the control properties, we saw the default appearance and behavior.
Obviously, it would be difficult to write a control that was generic enough to be widely useful without allowing for
customization. Yet, that is the driving philosophy behind ActiveX controls. A well-designed ActiveX control
provides a great deal of flexibility by providing methods, properties, and events. An ActiveX control fires events to
communicate with its control container. The container, in return, uses methods and properties to communicate with
the control. In this section, well learn about control properties and how to manipulate them. In the next section,
well talk about methods and events.
Simply put, properties are data members of the ActiveX control that are exposed to any container. Properties
provide an interface for applications that contain ActiveX controls, such as Automation clients and ActiveX control
containers. By manipulating the properties of a control, we can customize its default appearance and behavior.
Exercise 6-4 Setting ActiveX Control Properties
Suppose the application we are writing requires that weeks begin on Monday, rather than Sunday. We can easily
modify the MonthView control to meet this requirement, as illustrated in the following steps:
2. Switch to ResourceView and expand the Dialog folder.
3. Double-click the IDD_CALENDAR_DIALOG dialog box. This opens the application dialog for editing in the
dialog editor.
4. Right-click the MonthView control and select Properties MonthView Object from the pop-up menu. This
opens the MonthView properties dialog box.
5. Click the Control tab.
6. Using the drop-down list, change the value of the Start of Week item from mvwSunday to mvwMonday, as
shown in Figure 6-6.
Figure 6: Changing the StartOfWeek item on the Control tab of the MonthView Control Properties dialog box
7. Close the MonthView Control Properties dialog box.
8. Select the File | Save menu entry to save the modifications.
Notice that the MonthView control now displays weeks that run from Monday through Sunday, rather than Sunday
through Saturday, as shown in Figure 6-7.
Figure 7: The modified dialog box, displaying weeks that begin on Monday
The MonthView control provides a number of properties that you can modify through the Properties dialog box.
Spend some time experimenting with different properties and determine how they affect the appearance and
behavior of the control. When youre finished, close the dialog editor without saving your changes. Well be using
this project in the next lesson and we want to have the properties set the way we saved them at the end of the
exercise.
In the previous example, we learned how to set the properties of an ActiveX control and spent some time
experimenting with the options available. This is fine for simple controls, but what if you need more information
about the properties, methods, and events that a control supports?
Fortunately, most controls provide a help file that contains this kind of information. The following exercise
demonstrates how you can access this information.
Exercise 6-5 Getting More Information about an ActiveX Control
2. Select the Project | Add to Project | Components and Controls menu entry to open the Components and
Controls Gallery dialog box.
3. Open the Registered ActiveX Controls folder. This lists all of the ActiveX components that are registered on
your computer.
4. Select the Microsoft MonthView Control, version 6.0.
5. Click the More Info button. This opens a help file, as shown in Figure 6-8.
Figure 8 : Use the Help file to obtain information on using the MonthView control
6. Close the Components and Controls Gallery dialog box by clicking the Close button.
As you can see, the help file provides extensive information about the MonthView control and the properties,
methods, and events it supports. Leave this help file open because well be referring to it in the next lesson, where
well learn how to use methods and events to interact with the MonthView control within our MFC application.
Handling an Event from an ActiveX User Interface
Control
In the previous section, we learned how to add an instance of the MonthView control to a dialog box and manipulate
its properties to customize the default appearance and behavior. So far, all of our interaction with the control has
been at design time. As we saw, ActiveX controls provide a great deal of power and flexibility that we can use in our
applications.
But, suppose that you want to extend the default functionality provided by the control. Perhaps you would like to
change the appearance of the control dynamically at runtime based on user input. Or, you might want to customize
the controls response to a particular user action.
Fortunately, most ActiveX controls provide methods and events that allow you to accomplish these goals. In this
section, well learn about methods and events and how to utilize them to interact with a control from its containing
MFC application.
Methods are similar in usage and purpose to the member functions of a C++ class. Control methods can be called
from a containing application to do useful work, such as dynamically changing control properties or accessing some
functionality provided by the control.
ActiveX controls use events to notify a container that something has happened to the control. An example might be a
user-input event, such as a mouse-click or a keyboard event. Such an event would cause the control to fire an event
to alert the container. By responding to these events, our application can customize the default behavior of the
control.
Suppose that you were writing an application to schedule hard disk backups, and wanted to allow the user to select
the backup date using a MonthView control. Your application would need to respond to the MonthView controls
SelChange event so that it could respond appropriately when the date was changed.
Well emulate this by adding a couple of controls to our Calendar applications dialog box to display the currently
selected backup date. Then well learn how to add code to update these controls when the user changes the date
using the MonthView control.
Exercise 6-6 Using Methods and Events to interact with an ActiveX Control
Open the Calendar project (if its not already open). 1.
Switch to ResourceView and expand the Dialog folder. 2.
Double-click the IDD_CALENDAR_DIALOG dialog box. This opens the application dialog for editing in the
dialog editor.
3.
Select the Static Text tool on the Controls toolbar and place a static text control in the dialog box. Then,
right-click the control and click Properties in the shortcut menu to open the Text Properties dialog box. In this
dialog box, change the static text control caption to Backup Date:.
4.
Select the Edit Box tool on the Controls toolbar and place an edit box control next to the static text control in
the dialog box. Then, right-click the control and click Properties in the shortcut menu to open the Edit
Properties dialog box. On the General tab, change the edit controls ID to IDC_BACKUPDATE. On the
Styles tab, click Read-only.
5.
Using the dialog editor, arrange the controls as shown in Figure 6-9. 6.
Figure 9: Use the Dialog editor to add new controls to the Calendar dialog box
At this point, were ready to add code to allow our program to interact with the MonthView control at runtime.
When we add an ActiveX control to our project, the Component and Controls Gallery automatically adds the
appropriate wrapper class implementation file (.CPP) and header file (.H) to the project. To get and set properties
and invoke methods for the MonthView control, the CMonthView wrapper class provides a declaration of all
exposed methods and properties. These functions can then be called from other application procedures using normal
C++ syntax. In this example, these declarations are found in MONTHVIEW.H
After the ActiveX control has been added to the project and embedded in the dialog box container, it can be accessed
by other parts of the project. The easiest way to access the control is to create a member variable of the dialog class,
CCalendarDlg, that is of the same type as the wrapper class added to the project by the Component and Controls
Gallery. You can then use the member variable to access the embedded control at any time.
Exercise 6-7 Adding a Member Variable for a Control to a Dialog Box
The following steps illustrate adding a member variable for the MonthView control to our CCalendarDlg dialog box.
From the View menu, click ClassWizard. 1.
Choose the Member Variables tab. 2.
In the Class Name list box, select the main dialog class CCalendarDlg. 3.
In the Control Ids list box, select the control ID of the MonthView control, IDC_MONTHVIEW1. Your
settings should now match those shown in Figure 6-10.
4.
Figure 10: Using ClassWizard to add a member variable for the MonthView control to the main dialog box
Click the Add Variable button to open the Add Member Variable dialog box. 5.
In the Member Variable Name box, type the name m_monthViewCtl. 6.
In the Category box, select Control. 7.
Verify that the Variable Type edit box contains the name of the control wrapper class, CMonthView. Your
settings should now match those shown in Figure 6-11.
8.
Figure 11: Adding the m_monthViewCtl member variable
Click OK to close the Add Member Variables dialog box. 9.
Click OK to accept these changes and exit ClassWizard. 10.
Thats all there is to adding a member variable for the MonthView control to our main application dialog box. Now
we can use common C++ syntax to access the properties and methods of the embedded control.
A common place to modify the properties of a control is in the OnInitDialog member function of the main dialog
class. This function is called just before the dialog box appears and is used to initialize its contents.
The following code example uses the m_monthViewCtl member variable to access the currently selected date within
the MonthView control. It then converts this value to a string and uses the string to initialize the Backup Date edit
control.
Well add the following line of code to call a member function to set the value of the IDC_BACKUPDATE edit
control. Well be adding this member function next.
SetBackupDateEditCtl(m_monthViewCtl.GetValue());
This line should be added near the end of the CCalendarDlg::OnInitDialog function, after the TODO comment line.
The finished function should look like this:
BOOL CCalendarDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// Add "About..." menu item to system menu.
// IDM_ABOUTBOX must be in the system command range.
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);
CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
CString strAboutMenu;
strAboutMenu.LoadString(IDS_ABOUTBOX);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
}
}
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
// TODO: Add extra initialization here
SetBackupDateEditCtl(m_monthViewCtl.GetValue());
return TRUE; // return TRUE unless you set the focus to a control
}
We added a call to a member function that sets the contents of the Backup Date edit control, IDC_BACKUPDATE,
based on the value of an input variable of type DATE. Notice that in the argument to this function, we use the
member variable that we created, m_monthViewCtl, to access the GetValue member function of the MonthView
control. The GetValue function returns the current setting of the Value property. Most ActiveX controls supply
member functions that allow you to get and set their internal properties in this way.
Exercise 6-8 Adding a Member Function to the CCalendarDlg Class
In the previous code sample, we added a call to this member function. Now we need to add this member function to
the CCalendarDlg class, as illustrated in the following steps.
Switch to ClassView. 1.
Right-click the CCalendarDlg class and select Add Member Function from the shortcut menu to open the Add
Member Function dialog box.
2.
In the Function Type box, type void. 3.
In the Function Declaration box, type SetBackupDateEditCtl(DATE currentDate). 4.
In the Access box, select Protected. Your entries should now match those shown in Figure 6-12. 5.
Figure 12: Adding the SetBackupDateEditCtl member function to the main dialog class, CCalendarDlg
Click OK to add the member function. 6.
a skeleton of the new member function, SetBackupDateEditCtl, is added to the CCalendarDlg class, as shown:
void CCalendarDlg::SetBackupDateEditCtl(DATE currentDate)
{
}
Add the following lines of code to the function body:
COleDateTime date(currentDate);
CWnd* pWnd = GetDlgItem(IDC_BACKUPDATE);
pWnd->SetWindowText(date.Format(VAR_DATEVALUEONLY));
The first line of code creates a variable called date of the type COleDateTime. The value of this variable is
initialized using the input currentDate variable. The second line of code gets a pointer to the Backup Date edit
control, IDC_BACKUPDATE. In the third line of code, this pointer is used to call its SetWindowText member
function. The Format member function of the COleDateTime class is called to convert the date value to a formatted
string.
If we test our program at this point, well see that when the main dialog box opens, the Backup Date edit control is
correctly initialized to the currently selected date within the MonthView control. However, if we select a different
date in the MonthView control, the Backup Date is not updated.
In the following steps, well learn how to add an event handler to remedy this problem.
Open the main dialog box, IDD_CALENDAR_DIALOG, in the dialog editor. 7.
Right-click the MonthView control and click Events in the shortcut menu to open the New Windows Message
and Event Handlers for class CCalendarDlg dialog box.
8.
In the Class or Object to Handle list box, select IDC_MONTHVIEW1. 9.
In the New Windows Messages/Events list box, select SelChange. Your settings should now match those
shown in Figure 6-13.
10.
Figure 13: Adding a new Windows message for CCalendarDlg
Click the Add and Edit button. This will open the Add Member Function dialog box. 11.
When the Add Member Function dialog box appears, confirm that the Message is SelChange and the Object
ID is IDC_MONTHVIEW1, then accept the default function name of OnSelChangeMonthview1 by clicking
the OK button.
12.
a skeleton of the new event handler member function, OnSelChangeMonthview1, is added to the CCalendarDlg
class, as shown:
void CCalendarDlg::OnSelChangeMonthview1(DATE StartDate, DATE EndDate, BOOL Far* Cancel)
{
}
Replace the TODO comment line in the function body with the following line of code:
SetBackupDateEditCtl(StartDate);
Now that weve added an event handler for the SelChange event, it will be called whenever the user selects a new
date in the MonthView control. The parameters to this function include the StartDate and EndDate variables of type
DATE. Both of these dates are included because, by changing a property of the MonthView control, you can
configure it to allow a selection range. Because were using the default properties that allow the selection of a single
date, well be interested only in the value of the StartDate variable. The value of StartDate represents the newly
selected date.
The line of code that we added to the function body sets the value of the Backup Date edit control,
IDC_BACKUPDATE, to the date passed to the function in the StartDate variable.
Test the program now that weve added the event handler. Youll see that the Backup Date edit control is correctly
updated when the user selects a new date in the MonthView control. You have successfully added an event handler
to an ActiveX control!
Dynamically Creating an ActiveX User Interface Control
Using these features of Visual C++ allows us to create very user friendly and useful applications. Properly designing
dialog boxes to help users interact with our applications will help them to be more productive when using these
programs. Using the Dialog editor, we are able to design these dialogs with ease. There are times, however, when we
are not able to use the Dialog editor to place these controls onto the dialogs and windows in our applications. When
needed, Visual C++ allows us to dynamically add these to our project. In this section we will be discussing how this
is done.
Adding controls dynamically at runtime can be as simple as creating a new instance of an existing control onto a
defined dialog or as complex as having the user specify the type of control to be added to a window. We will use an
example that falls somewhere between these two extremes. This example will show you how to add a control and
allow you to respond to the events that are raised by the control. Adding controls that we do not know about in
advance is an advanced concept and beyond the scope of the tests or this book.
Exercise 6-9 Dynamically Adding an ActiveX Control at Runtime
In this example we will duplicate some of the functionality that we created in the last exercise, but this time we will
do it by adding a MonthView control to the view in an SDI application. By now you should be very familiar with
using the AppWizard, so we will not detail those steps in this exercise.
1. Select File | New from the menu and create a new MFC AppWizard (exe) project type.
Name the project DynamicControl and ensure that the Create New Workspace option button is selected. 2.
In step 1 of the wizard, select a Single document as the type of application to create. Accept the defaults in
step 2. In step 3, be sure the ActiveX Controls check box is selected. select Finish and create the application.
3.
Again, we will be using the MonthView control from Microsoft and so we will need to add it to this project as
we did before. To do this, select Project | Add to Project | Components and Controls. Open the Registered
ActiveX Controls folder and select the Microsoft MonthView Control, Version 6.0 control. click the Insert
button. When prompted, click OK to insert the component into the project. Select OK to accept the default
class names. Finally, click Close to close the Components and Controls Gallery dialog box. We have now
created the necessary wrapper classes for the MonthView control.
4.
The next step is to add a Resource Symbol for the control that we will add at runtime. To do this, select View |
Resource Symbols. Then select New and type IDC_SELECTDATE. Accept the default value as shown in
figure 6-14. Click OK to create the symbol. select Close to close the Resource Symbol dialog.
5.
Figure 14: Adding the IDC_SELECTDATE symbol to our application
As stated earlier, the goal of this exercise is to add a MonthView control to the View window of our SDI
application. In step 4 we created the wrapper classes that define the behaviors of the MonthView control. To
6.
allow the View class to interact with this control, we now need to add the monthview.h header file to the
DynamicControlView.h header file. Place this include statement before the class definition in the file as
shown.
#include MonthView.h
class CDynamicControlView : public CView
{
The next step is to add a member variable to our CDynamicControlView class. To do this, right-click the
CdynamicControlView class on the Class View tab and select Add Member Variable. Specify CMonthView
as the variable type and m_monthSelectDate as the variable name. Set the access mode to Protected, and it
should look like the dialog shown in Figure 6-15. Finally, click OK to create the variable.
7.
Figure 15: Adding the m_monthSelectDate member variable to the view class, CDynamicControlView
The next step is to actually create the control. In our example, we will need to add a message handler to our
view class. To do this, open classwizard and select as the class name, CDynamicControlView. Next, be sure
that the Object ID that is selected is also CDynamicControlView. In the Messages list, select WM_CREATE
and click the Add Function button. At this point, the classwizards Message Maps tab should look like Figure
6-16.
8.
Figure 16: Adding the OnCreate function to the view class, CDynamicControlView
From the ClassWizard, click Edit Code. This will take us to the new message handler that we created and
allow us to add code to create our control.
9.
Now that we are editing the code, we need to call the Create method of our m_monthSelectDate object from
the OnCreate method of the CDynamicControlView class. The code is shown here.
10.
int CDynamicControlView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CView::OnCreate(lpCreateStruct) == -1)
return -1;
// TODO: Add your specialized creation code here

m_monthSelectDate.Create(NULL, WS_VISIBLE,
CRect(20,20, 100, 100), this, IDC_SELECTDATE);
return 0;
}
The only call that we have added to the stub code provided by Visual C++ is the call to the Create method of the
m_monthSelectDate object. We have provided five parameters to this method. The following table identifies each
parameter and indicates the reason why we have supplied each value. Note that the words control and window are
often used synonymously in the descriptions in the table. Remember that the MonthView class is derived from the
CWnd class and that the control is a special case of a window. I used the terms as I felt they would make the most
sense.
Parameter Value Description
lpszWindowName NULL String containing the name of the window we
are creating. In our case, this is NULL.
dwStyle WS_VISIBLE Specifies the style or styles that are desired for
the created window. In our case, we simply are
going to ensure that it is visible.
rect Crect(20, 20, 100, 100) This is intended to specify both the size and the
position of the control based on the parent. In
the case of the MonthView control, the size is
predetermined, so the only parameters that
matter are those that specify the position.
pParentWnd this The parent window of the window that we are
creating. In our case we are passing this pointer,
which is actually the CDynamicControlView
object.
nID IDC_SELECTDATE This is the ID of the window that is being
created. This can be left as a NULL, but in our
case we will need the control to have an ID so
that we can respond to events that it raises.
With this code added, we are now ready to build and test our application. We have now completed all of the
steps required to dynamically add a control to our application at runtime. Select Build | Execute
DynamicControl.exe and confirm that you want to build the application.
11.
Take a moment to exercise the functionality of the control on the view. You will see that it acts just like it did
in our earlier example when a dialog box hosted it. Yet it is not yet very useful to us. In the following steps,
we will add the required features that will allow us to respond to the events that this control can raise, again
acting as it did in our previous example. You can see an image of how this application looks in figure 6-17.
12.
Figure 17: An SDI application running with a control that was added at runtime
Now that we have added the control, and the application is functioning properly, it is time to do something useful
with it. In the next few steps we will add the capability to have our View class respond to events that are raised by
this instance of the MonthView control.
The first step is to add the Event Sync and function mappings. This can be a tedious process, unless you know
a good trick. Luckily we know a trick and have prepared ourselves to make this an easy step. Open a second
copy of Visual C++ and load the Calendar project from our earlier exercise. We will be borrowing some code
from a Dialog-based application to use in our new SDI application.
13.
Next, using the File View tab, locate and open the header file CCalendarDlg.h. Move to near the bottom of the
file and copy the following lines to the clipboard:
14.
afx_msg void OnSelChangeMonthview1(DATE StartDate, DATE EndDate,
BOOL FAR* Cancel);
DECLARE_EVENTSYNC_MAP()
I have purposefully changed the ID of our control so that we will better understand all of the steps that must
be completed for the piracy of code to work. Now return to our DynamicControl application. Using the File
View tab, locate and open the header file CDynamicControlView.h.
15.
Move towards the bottom of the file and locate the message map. Next, paste the code from the clipboard into
the message map and change OnSelChangeMonthView1 to OnSelChangeSelectDate. Although this change
is not really required, it will make the code easier to read. This new name is more like the name that
ClassWizard would assign if this control were not being created dynamically. Now your message map should
look like the following:
16.
afx_msg void OnSelChangeSelectDate(DATE StartDate, DATE EndDate,
BOOL FAR* Cancel);
DECLARE_EVENTSYNC_MAP()
Next, return to the Calendar project and open the file named CCalendarDlg.cpp. Again, move towards the
bottom of the file and find the code that implements the Event Sync map and the OnSelChangeMonthView1
event handler. Copy this code to the clipboard. The code that you should copy is listed here.
17.
BEGIN_EVENTSYNC_MAP(CCalendarDlg, CDialog)
//{{AFX_EVENTSYNC_MAP(CCalendarDlg)
ON_EVENT(CCalendarDlg, IDC_MONTHVIEW1, 4 /* SelChange */,
OnSelChangeMonthview1, VTS_DATE VTS_DATE VTS_PBOOL)
//}}AFX_EVENTSYNC_MAP
END_EVENTSYNC_MAP()
void CCalendarDlg::OnSelChangeMonthview1(DATE StartDate, DATE EndDate, BOOL FAR* Cancel)
{
SetBackupDateEditCtl(StartDate);
}
You can now close the Calendar project and return to our DynamicControl project. Using the File View tab,
open the file named CDynamicControlView.cpp. Move to the bottom of the file and paste the code from the
clipboard. Now we will have to make some changes to this code.
18.
The first change will be replacing each reference to CCalendarDlg with a reference to
CDynamicControlView (you might want to use Edit | Replace to do this). A change that is associated with
this is to change the second parameter of the BEGIN_EVENTSYNC_MAP macro from CDialog to CView.
This is because we are now using a CView-derived class rather than a CDialog-derived class.
19.
Next change IDC_MONTHVIEW1 to IDC_SELECTDATE in the Event Sync map. Here you can see that if
we had created the new symbol with the same name as in our Calendar project, we would not have to edit so
much. Remember this when working in the real world, but be sure to learn what is really happening.
20.
Next we need to replace the method name in all of the code we copied. In our Calendar project, our method
was named OnSelChangeMonthView1. In our new project we have decided to call this
OnSelChangeSelectDate. Make the changes now; it will have to be done in two places.
21.
The final step is to add the functionality that we desire to the new method. In the Calendar project, we made a
call to SetBackupDateEditCtl. In this project we will display the date below the MonthView control on the
view. To do this, place the following code into the OnSelChangeSelectDate method and remove the call to
SetBackupDateEditCtl. (Notice that we are doing something very similar to what the SetBackupDateEditCtl
method did.)
22.
COleDateTime date(StartDate);
CClientDC DrawDC(this);
DrawDC.TextOut(30, 200, date.Format(VAR_DATEVALUEONLY));
The code at the bottom of the CDynamicControlView.cpp file should now look like the following: 23.
BEGIN_EVENTSYNC_MAP(CDynamicControlView, CView)
//{{AFX_EVENTSYNC_MAP(CDynamicControlView)
ON_EVENT(CDynamicControlView, IDC_SELECTDATE, 4 /* SelChange */,
OnSelChangeSelectDate, VTS_DATE VTS_DATE VTS_PBOOL)
//}}AFX_EVENTSYNC_MAP
END_EVENTSYNC_MAP()
void CDynamicControlView::OnSelChangeSelectDate(DATE StartDate, DATE EndDate,
BOOL FAR* Cancel)
{
COleDateTime date(StartDate);
CClientDC DrawDC(this);
DrawDC.TextOut(30, 200, date.Format(VAR_DATEVALUEONLY));
}
Now run the application by selecting Build | Execute DynamicControl.exe and allowing Visual C++ to build
the new executable. Exercise the functionality of the MonthView control and you should see the selected date
appearing below the control for each date selected. Figure 6-18 is a screen image of this exercise running.
24.
Figure 18: The SDI application now handles an event raised by the control
In this section, you have seen how you can add a control to an MFC application at runtime. It is important to
understand this functionality, and it can be very helpful as you are creating applications for your customers.
Using the Internet Server API
In this section, well be talking about the Internet Server Application Programming Interface (ISAPI). The ISAPI
provides a simple and efficient way to extend any ISAPI-compliant Web server. Using it, you can write ISAPI
dynamic link libraries (DLLs) that can be loaded and called by a Hypertext Transfer Protocol (HTTP) server.
There are two types of ISAPI DLLs that you can create. They are:
ISAPI server extensions
ISAPI filters
ISAPI Server Extensions
An ISAPI server extension, sometimes called an Internet server application (ISA), is a DLL that can be loaded and
called by an ISAPI-compliant server to enhance its capabilities. An ISA is invoked from a browser application and
provides functionality similar to that of a Common Gateway Interface (CGI) application. An ISA is only executed
when the browser navigates to the URL that identifies the server extension. This will be seen in the exercise that we
will do shortly. Using an ISA, you can develop an application that processes data collected in a Web page and, based
on that data, dynamically creates and sends customized Hypertext Markup Language (HTML) data to the client for
display to the user.
Later in this section, well work through an example that creates an ISAPI server extension.
ISAPI Filters
ISAPI filters provide the capability of preprocessing and postprocessing of all data sent between the client and the
server. Filters have no CGI equivalent. Whereas an ISAPI server extension DLL is loaded when first requested, an
ISAPI filter is loaded when the web server is started. This filter can then be used for all interactions with the web
server. When you choose to create an ISAPI filter, you have seven notifications that you can filter. The following is
the list of these.
Incoming raw data and headers
Outgoing raw data and headers
Post- and preprocessing of the request headers
Client authentication requests
URL mapping requests
Server log writes
End of connection notification
Filters are not as common as extensions. The most important thing to know for the test is that extensions process
when requested, and filters process all of the time. We will not look at an example of a filter in this chapter.
Advantages of Using ISAPI DLLs
There are several advantages to using ISAPI server extensions as an alternative to traditional CGI applications.
ISAs run in the same address space as the server and have access to all of its resources.
ISAs do not require the creation of additional processes and do not perform communications across process
boundaries. As a result, ISAs have lower overhead than CGI applications.
The server may unload both extension and filter DLLs if the memory is needed by another process.
Using the MFC AppWizard to create an ISAPI DLL
Visual C++ gives us tools to help create ISAPI DLLs. As with many of the other types of applications that we can
build with VC++, there is a wizard to help us build these extensions. In the following exercise we will create an
ISAPI extension DLL that will return a customized message to the user.
Exercise 6-10 Creating the ISAPI DLL Project
Select the File | New menu entry. This opens the New dialog box. 1.
Click the Projects tab and select ISAPI Extension Wizard as the project type. Type Message for the project
name. click OK.
2.
In Step 1 of 1 of the ISAPI Extension Wizard, select the Generate a Server Extension object check box.
Accept the defaults for the class name and description. select to have the MFC DLL used as a shared DLL.
Your selections should look like Figure 6-19.
3.
Figure 19: Selecting the options for an ISAPI extension DLL
VC++ has now generated an ISAPI extension DLL with a class that it has derived from CHTTPServer. This class
has no functionality in it, but it does have a method name default, which is often used with server extensions.
To help us to learn more about ISAPI DLLs, we will not use the default method, but rather we will create a new one
called GetMessage. This method will be called by the browser when the user wants to run our server extension. To
do this, perform the following steps.
Adding a new method to the CMessageExtension class involves multiple steps. First we must add the method
to the Parse Map. To do this open the file named CMessageExtension.cpp and move to the top of the file.
Locate the Parse Map and add the following lines.
4.
ON_PARSE_COMMAND(GetMessage, CMessageExtension, ITS_PSTR)
ON_PARSE_COMMAND_PARAMS("Name")
Next we must add the actual method to the class. To do this, right-click the CMessageExtension class in the
Class View and select Add Member Function. Set the function type to be void and the function declaration to
be GetMessage(CHttpServerContext* pCtxt, LPCTSTR pstrName). Your Add Member Function dialog
box should look like figure 6-20. The pCtxt parameter is an object that provides the context for each
transaction between the browser and the server. The pstrName parameter will read the name from the user that
will be used when creating our message.
5.
Figure 20: Adding the member function for our ISAPI extension server
Next we will add one more method to our CMessageExtension class. This method will be used to set the title
for the browser when the results from our DLL are displayed. To do this, once again right-click the
CMessageExtension class in the Class View and select Add Member Function. Set the function type to
LPCTSTR and the function declaration to GetTitle() const, as shown in figure 6-21.
6.
Figure 21: Setting the function type and the function declaration for the member function
Next we will implement the GetTitle method. To do this, locate the code stub and add the following code to it. 7.
return "A Special Message";
Finally, we will add the code for the GetMessage method. This method will accept the name of the user as a
parameter and generate a message for the user. Add the following code to the stub created for this method.
8.
// setup the Html to be returned
StartContent(pCtxt);
WriteTitle(pCtxt);
// add the custom content
*pCtxt << "Hello, ";
*pCtxt << pstrName;
*pCtxt << " I hope you are having a good day!";
// close the html
EndContent(pCtxt);
The final step, as far as VC++ is concerned, is to create our DLL. To do this, select Build | Build Message.dll
from the menu. This will create the ISAPI extension DLL for you. Because we are not trying to cover the
details of Internet Information Server (IIS), we will skip the steps required to publish this to your web
serverthese are not required for the testand move on to show you the outcome of the process.
9.
After you have published this DLL to your web server, you will most likely build a form from which this will
be executed. Again, our focus is to understand the dll and not HTML, so we will simply type the request into
the Address line of our browser. Type the following address into your browser and replace the server name
with the name of your development IIS server:
10.
http://qss3/ISAPIExt/Message.dll?GetMessage?Name=Phred
Doing this will result in Figure 6-22 being displayed in your browser. 11.
Figure 22: Output from our ISAPI extension server
Notice that the title has been changed, as we requested, to A Special Message. Also the message that we created has
also been displayed.
It is worthwhile to remember the three classes with which we have interacted in creating this ISAPI extension. We
have actually worked with two of them directly, and the third has served us without actually showing itself. The
following are the three MFC classes which we have used.
CHttpServer is the class from which our CMessageExtension was derived. This is the main focus of our DLL, and
without it we would not be able to create the extension DLL. When the wizard created our class for us, it gave us a
method for our derived class called Default. If the request to our DLL does not specify the method to be called, the
Default method will be called.
CHttpServerContext is the first parameter that is passed into our GetMessage method. This class represents the
information that is required for each interaction between the browser and the server. We used this object to allow the
CMessageExtension, StartContent, WriteTitle, and EndContent methods to build the framework of our html page
that was returned to the browser. A new object is created for each interaction between the browser and the server.
Finally, the CHtmlStream class was hidden from us in this example. Nonetheless, it is a very important class. The
CHttpServerContext class has a member variable called m_pStream which is of this class. This is the class that
actually manages the creation of the stream that is returned to the browser. The overloaded << operator of the
CHttpServer class actually calls the Write method of this class to place the data we desire into the stream.
To give you a fully-rounded view of ISAPI extensions, we will also introduce the classes that are pertinent when
creating an ISAPI filter. In this case there are only two classes and they are described in the following paragraphs.
CHttpFilter is the main class for an ISAPI filter. It is somewhat analogous to the CHttpServer class in the extension
arena. This class has virtual functions for each of the notifications that we discussed earlier. It is important that you
override only the functions for those notifications that you desire to filter. this will cause only those functions to be
called, giving better performance.
CHttpFilterContext is somewhat like the CHttpServerContext we discussed earlier. An object is created for each
interaction between the browser and the server. This object is available to you from each of the virtual functions that
are provided by the CHttpFilter class.
Incorporating Dynamic HTML Scriptlets
The Internet seems to keep rolling forward and gaining speed as it does. that is, the trend is gaining speed, not the
Internet itself. As such, Visual C++ is adding more and more support for Internet technologies. In this section we
will cover some of these features which allow the incorporation of Dynamic HTML into our projects.
The first step to incorporating a Dynamic HTML script into an application is to create a host in which the HTML
will be displayed. This is most often accomplished by creating a View class that is derived from CHTMLView.
CHTMLView provides the functionality of a Web browser in a view window within our application. Once we have
created our host, we must then also create the DHTML script that will be viewed.
To understand the importance of this, lets quickly review what a DHTML script is. The Web provides a fairly rich
environment for the user. It is very graphical and can be very flashy. Originally, the web required that all of the
information that was to be displayed be created and formatted at the server. Then, this content was transferred to the
browser for viewing. Whenever the formatting, or the content, was to change, it would require a round trip back to
the server. DHTML is one of the ways that this round trip can be avoided. Using DHTML, the web author can add
scripting code to the HTML page that will run at the browser. This allows both the content and the formatting of the
page to change without returning to the server. DHTML gives the user a more interactive and rich environment
without slowing the process down by requiring trips to the server.
To better understand how this is accomplished, we will work through an exercise that will display a DHTML script
within a Visual C++ project.
Exercise 6-11 Creating a DHTML Script and displaying it within a VC++ Project
1. Select the File | New menu entry to create a new project.
2. Click the Projects tab and select MFC AppWizard (exe) as the project type. Type
DHTMLScript as the project name, and click OK.
3. Accept all of the defaults for the wizard except select Single Document rather than Multiple
Documents, and on the final step (6 of 6) change the Base Class for CDHTMLScriptView from CView to
CHtmlView. This dialog is shown in figure 6-23.
Figure 23: Use AppWizard to change the base class for our DHTML exercise
Steps 1 through 3 create the container for our DHTML script. In the following steps we will create the DHTML
script as a resource in our project and modify the application to display it on startup.
4. Select Insert | Resource from the menu and add an HTML resource. Although we could navigate
to any HTML file on our local machine or the Internet, we will add the script as a resource in our project.
5. Change the name of the HTML resource to IDR_DHTML by right-clicking in the rightmost
pane and selecting properties.
6. Now we will type the HTML into the rightmost pane. As with the other resource editors, the
HTML resource editor has been created to manage HTML resources. Thus, we have an editor that is color-keyed to
the HTML syntax. Add the following DHTML script to the HTML editor.
<HTML>
<Script Language="VBScript">

</Script>
<Title>
A DHTML Example with Visual C++
</Title>
<Body>
<H1 ID=MyHeader onmouseover="ChangeColor" onmouseout="ReverseColor">
This is a message</H1>
</Body>
</HTML>
Our goal here is not to make you an HTML expert, but simply to provide an HTML file with DHTML script that
will demonstrate some of what you are able to do. In this case, we have created a level one header that will change to
red when the mouse moves over it and will return to black when the mouse is not over it. Lets continue the exercise
by modifying our code to display this resource when we start our application.
7. Open the OnInitialUpdate method of the CDHTMLScriptView class. In this method, you will
find the following line of code that was inserted by the wizard:
Navigate2(_T("http://www.microsoft.com/visualc/"),NULL,NULL);
Replace this line with the following line:
LoadFromResource(IDR_DHTML);
This will cause the resource we created to be loaded when the application starts.
8. We are now ready to build our application and take it for a test run. Select Build | Execute
DHTMLScript.exe from the menu and have VC++ create and run the application. You should see Figure 6-24.
Although we cannot show it here in the book, when you move the mouse over the text in the browser window, you
should see the text change to red.
Figure 24: Output from our DHTML exercise
Although this exercise has not created an application that is truly functional for a corporate customer, you would be
wise to watch the trends as they move towards the Internet and be prepared to incorporate these features into
applications when and where they make sense. This is not only wise for your real world work, but you should have
some understanding of these topics for the tests.
Invoking a COM Component
So much of the current talk in the software development world now focuses on components and component
development. Of course as we well know when we are talking about a Microsoft tool, these are obviously
Component Object Model (COM) components. These days, the benefits of component development are well known
and most would argue that this is the way to develop software. In other parts of this book, we have talked about how
to build various COM components. In this section we will learn how to invoke and use these components in a
regular executable.
In the following exercise we will create an instance of a COM component. This component is a simple one that I
have created for this exercise. Because a component is a black box of sorts, we do not really need to see the code for
it. This component simply exposes one method. If you wish, you may change this example to work with a
component that already exists on your system, or you may choose to use the information from some of the other
chapters to build your own component. The method exposed by my component is GetAge, which takes the id of an
employee and returns the age of that employee.
Exercise 6-12 Invoking a COM Component
1. Select the File | New menu entry to create a new project.
2. Click the Projects tab and select MFC AppWizard (exe) as the project
type. Type MyCOMClient as the project name and click OK.
3. For this exercise, we will change only two of the default settings for the
AppWizard. The first is in Step 1 where we will choose to create a Single Document rather than a Multiple
Documents type of application. The second change to the defaults is in Step 3, where we will select Container as the
type of compound document support to include in the application.
4. click Finish to build the application.
5. Now add the following line near the bottom of the StdAfx.h header file:
#import "D:\MyCOMSvr1\Debug\MyCOMSvr1.dll" no_namespace
This line really does most of the work for us. I have imported the DLL that I am using. You will need to modify the
#import the DLL of your choice. The #import directive causes VC++ to do all of the detail work for us. You will
soon see just how easy it is to use a COM component. The no_namespace allows us to refer to the component
without using namespaces.
6. Next, navigate to the OnDraw message handler of the
CMyCOMClientView class. This is where we will create and use our component. Of course this is a very simple
exercise, but the techniques are the same when working with real-life components.
7. Under the //TODO comment, add the following lines of code:
CString msg;
IPersonPtr pPer(_uuidof(Person));
msg.Format("The age of employee number 3 is %d.\n", pPer->GetAge(3));
AfxMessageBox(msg);
The first and third lines of code are used to create and fill a CString object that will show the results of our method
call. We are displaying a message box that tells the age of the selected employee.
The real work happens in the second line. Here we are creating our object. We have declared it to be of type
IPersonPtr (our component exposes an IPerson interface). This type is created by our #import statement. (Look at the
.tlh file in the Debug directory of your project.)
With this magic known as smart pointers, we are able to create our object with that much ease. As a bonus, we also
do not have to manage the reference counting on our object because the smart pointer does this for us.
Now go ahead and build your client. Once it is built, you can test it. You will see the output from your method call.
As you can see, it can be very easy to create and use components in our applications. If you have worked with
components in the past you will quickly recognize that using these technologies, we no longer need to manage the
lifetime of our components by explicitly calling AddRef and Release. The smart pointers take care of this for us.
This is most certainly the easy way to approach it, and to really get the best understanding of it you should spend
some time and use some components by coding them longhand. It is also a good idea to have some knowledge of
this for the test. As a quick guide, here are the steps that you must complete to do this.
1. Create a standard MFC AppWizard (exe) application.
2. Include a header file describing your component in the class where
it will be used or in StdAfx.h
3. #include <afxole.h> in StdAfx.h.
4. Call AfxOleInit(); from the InitInstance method of the
CwinApp-derived class.
5. Declare your variables. This includes CLSID,
LPCLASSFACTORY, LPUNKNOWN, and a pointer to your interface.
6. Identify the CLSID by calling ::CLSIDFromProgID, passing in the
Program ID of your component.
7. Create the ClassFactory by calling ::CoGetClassObject.
8. Create an instance of your object by calling the CreateInstance
method of the ClassFactory. Have this give you an IUnknown pointer.
9. Get a pointer to your desired interface by calling the
QueryInterface method of IUnknown.
10. Now you are ready to use your component. You can see now why
smart pointers and the #import are so much better. Once you have finished with your object you still have work left
to do. Follow the next step to finish; this is important.
11. Call the Release method of the ClassFactory, the IUnknown
interface pointer, and your desired interface pointer.
Adding Asynchronous Processing
Many of the tasks that our applications must do are secondary to the actual work that the user is required to interact
with. There are many examples of cases in which we want a task to occur, but we do not want the user to have to
wait for it to complete before they continue on with other work. There are also cases in which we simply need to be
sure that a task will happen, but it does not need to be completed now.
The general nature of a program is to have a single thread of work occurring at one time. If we want to have several
things happening at the same time, we can start other threads. For the purposes of this book and for the certification
exam, these threads are commonly called worker threads. The programmer creates these threads for a specific task.
Then in the course of running the application, when the user desires the functionality, the program can create a
secondary, or worker thread, to perform the task. There are many issues that must be considered when creating these
threads. Refer to the section on thread synchronization in this book for more details.
Creating Secondary Threads
a secondary thread is created to perform a specific task. The program causes a thread to be created when the task is
to be accomplished, and the thread goes away on its own once it has finished the work. The following steps are
required to create a thread and start it executing within an application.
1.First, create a new procedure. Often this procedure is added within the same file as the class that will utilize it,
but it is not a method of that class. The prototype for the function is shown here.
UINT ThreadProcedure(LPVOID lpVoid)
2. An example of a true thread procedure is shown here
UINT SpellCheck(LPVOID DocToCheck)
{
CClientDoc* pDoc = (CClientDoc*)DocToCheck;
AfxMessageBox (pDoc->GetTitle());
return 0;
}
This thread procedure will display a message box when it is run that will show the title of the document that is
passed into it. As you can see, the parameter to the function is of type LPVOID. This allows us to pass a pointer to
whatever information that we need in the thread procedure. The thread procedure will cast the pointer to the type
that it is expecting, as we have done in the first line of code. Although we are showing a message box in this
example, that is probably not the best thing to do in a worker thread. But, it does allow us to see when the thread is
started. As for killing the thread, it will die once the thread procedure exits.
3. The next step is to actually create the thread. This is accomplished by calling the AfxBeginThread function.
The following is the prototype for this function:
CWinThread* AfxBeginThread( AFX_THREADPROC pfnThreadProc, LPVOID pParam, int nPriority =
THREAD_PRIORITY_NORMAL, UINT nStackSize = 0, DWORD dwCreateFlags = 0,
LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL );
The first parameter is the Thread Procedure. Here you can pass the name of the procedure.
The second parameter is the pointer that you wish to pass in. Remember that you must pass an LPVOID and then
cast it back to the desired type within the procedure.
All of the other parameters are optional. The thread priority can be set by passing the nPriority parameter. This
defaults to normal priority but can range from idle to time_critical. The stack size for the thread can be set using the
nStackSize parameter. This defaults to zero, which sets it to the same size as the parents stack. By setting
dwCreateFlags to CREATE_SUSPENDED you can cause the thread to be created but not actually executed until a
call to ResumeThread. Finally, you can use the lpSecurityAttrs parameter to set the security attributes of the thread.
Leaving this as the default value of NULL cases the thread to be created with the same security attributes as the
parent.
4. To create the thread, you must call AfxBeginThread as shown in this example code:
CWinThread* pThread=AfxBeginThread(SpellCheck, (LPVOID) pDoc);
In this example I have placed the call to AfxBeginThread in the OnDraw message handler of my CView
derived-class. I am passing in the pointer to the CDocument-derived object that is associated with this view.
It is as simple as that to create a worker thread. This is a powerful feature of VC++, but one that must be used with
caution. When used correctly, it can provide a performance increase to your applications.
Downloading ActiveX User Interface Controls
An exciting feature of ActiveX controls is that they are able to exist on a web page. To do this, we must ensure that
the control and all of the required files are on the computer on which the browser is running. We will often create a
.CAB file that can be referenced from the HTML.
Because the control must actually exist on the browsers computer, it is important to consider all that might be
required to have it run there. If we know that the user has all of the required files, we could simply refer to the .ocx
file itself from the HTML page. If this web page is to be viewed in a very controlled environment, such as an
intranet, this might be possible, but it is safest to provide the HTML page with information about all of the files that
might be required.
Before we go too much deeper, lets take a look at how the HTML page refers to the control. The following code is a
sample of what an <Object> tag in an HTML page might look like.
<OBJECT ID="MyControl1" WIDTH=75 HEIGHT=40
CLASSID="CLSID:09189208-B8D3-301B-5141-0400C8E3D523" CODEBASE="http:// MyWebServer
/MyCoolControl.cab#Version=1,0,0,001"> </OBJECT>
The most important things for us to look at here are the CODEBASE and the Version information. The CODEBASE
tells the browser where to go to get the control. Here we have told the browser to search for a file called
MyCoolControl.cab on a server named MyWebServer. Although this is fictitious, it is how a basic object would
appear on a normal web page.
The Version information is the first way in which we can help to minimize the impact of placing a control on our
web page. Remember that this control must exist on the machine on which the browser is running. This means that if
the control is not already on the machine, it will be downloaded from the location specified in the CODEBASE tag.
By supplying this information, the browser can check to see if this version of this control already exists on this
machine. If it does exist, it will not have to download anything.
Next, we need to identify what to include in the .CAB file. We need to be sure that this .CAB file can identify all of
the supporting files that will be required by the control. We also dont necessarily want to place all of them in it. For
example, if our control uses the MFC library, we will need to be sure that this is on the machine, but it is very
possible that it is already there, so we do not want the impact of downloading it again. To do this, we will create an
.inf file that identifies those supporting files and indicates from where they can be downloaded. When we create our
.CAB file we will only include the .ocx and the .inf files. If required, the browser will then follow the information
contained in the .inf file to gather all of the supporting files that it needs.
Using an Active Document
We have just reviewed some of the details that allow a developer to place an ActiveX control onto a web page and
provide a more appealing interface for the user. There are other means by which this can be accomplished. Earlier in
this chapter we reviewed DHTML. This technology also allows a developer to create a more appealing and
interactive experience for those that browse a web page. In this section we will talk about one more technology that
can give us an edge when developing web applications.
Active documents are actually standalone applications that can be hosted within a web browser. Using VC++ to
create an Active document server is really quite simple and straightforward. We will create a basic MFC AppWizard
(exe) application and provide it the means to run in a web browser.
Exercise 6-13 Building an Active Document Server
Select the File | New menu entry to create a new project. 1.
Click the Projects tab and select MFC AppWizard (exe) as the project type. Type MyActiveXDoc as the
project name, and click OK.
2.
Again, this is a pretty generic AppWizard application. Accept the defaults with the following exceptions. In
Step 1, select a Single Document application type. In Step 3, select Full-Server and Active Document Server,
as shown in figure 6-25. In Step 4, you will need to click the Advanced button and select a File Extension for
you application. We will use MYD, for My Document. Finally, in Step 6, change the base class for the view
to CFormView.
3.
Figure 25: Select the options in Step 3 to create an Active document server
Select Finish and allow the AppWizard to generate your project. 4.
Open the Dialog Resource named IDD_MYACTIVEXDOC_FORM and add two labels, two edit boxes, and
two command buttons, as shown in figure 6-26.
5.
Figure 26: Using the AppWizard, we can create this simple form for the Active document server
Behind the buttons on this form we would add code to interact with the Web server. In particular, we would
have the Submit button actually generate a POST request that the Web server could then process with an
ISAPI DLL. Because this is beyond the scope of this section, we will not actually add the code here, but for a
true Active document you would need to do this.
6.
Now build the application. Before we can see our document in the web browser, we will need to execute the
program and save a file. This file will have the extension of .myd as we requested in the AppWizard.
7.
Run your application and save a file. Save the file to C:\MyDoc.myd. Close the application. 8.
Open Internet Explorer and select File | Open. Click browse and browse to the file C:\MyDoc.myd. Open the
file. When prompted to Save the File or Open it from the current location, choose to open it from the current
location. You should see something that looks similar to figure 6-27.
9.
Figure 27: Our Active document running in Internet Explorer
There you have it. You have created an Active document server and hosted it within Internet Explorer. The
possibilities seem limitless. By using an Active document, you are not limited by the standard form items that you
are allowed to use in HTML. You can also create a standalone application, which is not possible when using
ActiveX controls on a web page. It seems that there are so many possibilities to choose from when creating web
applications that it can be hard to determine which is the proper technology to use. One word of advice is to use the
tools that you are comfortable with, but it can also be rewarding to spread your wings and learn some new tricks.
The following table contains some possible scenario questions regarding the use of ActiveX Controls and the
appropriate answer.
What should I do if I want to have a visual element to
display and edit data unique to my organization, and I
want to be able to have a consistent look and feel
between many different user interfaces?
Create an ActiveX control to interact with the data. This
will be available to many different development
environments including VC++ and the Internet.
How do I add an ActiveX control to my VC++ project
so that I can use it in a dialog box?
Use the Components and Controls Gallery to identify
the control and create a wrapper class for it.
What should I do when I dont know if a control should
actually be shown on a dialog box at runtime?
Add code to the project to allow the control to be added
dynamically when required. This also works to add
multiple instances of the control at runtime.
How can I filter the content of a web page that is being
delivered by my installation of Internet Information
Server 4.0?
Create an ISAPI filter to process the desired interactions
with the server.
Is it possible to change the content of a web page
without having to make a round trip to the server for a
new page?
Yes, you can use DHTML to create scripting that will
run within the browser and can change the design and
content of a web page without returning to the server.
A coworker has created an ActiveX component as a
DLL built with Visual Basic. How can I use this
component in my project?
The easiest way is to use the #import and smart pointer
functionality in VC++.
How do I cause a task to be performed in the
background without the user having to wait for the task
to complete?
Create a worker thread by calling AfxBeginThread.
If I want to use an ActiveX control on a web page, how
do I specify where to download the control from?
Use the CODEBASE tag in the <OBJECT> tag of the
HTML page.
In this chapter we have covered quite a bit of ground. We have discussed some of the general concepts that
originated the idea of using components. We have seen how to identify and use an ActiveX control from within our
VC++ projects. We not only reviewed the steps for using a control that was specified at design time, but we also
revealed the secrets behind creating controls at runtime.
We reviewed what Dynamic HTML is and how we can incorporate its functionality into a VC++ application. Next
we saw an example of how to create an instance of a component and use it from the VC++ code. In reviewing the
steps to use one of these components, we identified both the use of the #import directive and the explicit steps
required if we dont use the smart pointers provided by #import.
We also worked through an example that allowed us to create worker threads that can complete tasks that do not
require the user to wait until they have completed. finally, we learned how we can create Active document servers to
give us a rich user interface when working in a web environment. The skills that we have covered in this chapter are
very useful, both for the exam and for life on the job in the real world.
Two-Minute Drill
ActiveX is a set of technologies that enables software components to interact with each other in a networked
environment, regardless of the language in which they were created.
An ActiveX component is a unit of executable code, such as an .exe, a .dll, or an .ocx file, that follows the
ActiveX specification for providing objects.
ActiveX controls are reusable objects that include visual elements and code.
A well-designed ActiveX control provides a great deal of flexibility by providing methods, properties, and
events. An ActiveX control fires events to communicate with its control container.
Properties are data members of the ActiveX control that are exposed to any container.
ActiveX controls use events to notify a container that something has happened to the control.
When you add an ActiveX control to our project, the Component and Controls Gallery automatically adds
the appropriate wrapper class implementation file (.CPP) and header file (.H) to the project.
A common place to modify the properties of a control is in the OnInitDialog member function of the main
dialog class.
Adding controls dynamically at runtime can be as simple as creating a new instance of an existing control
onto a defined dialog or as complex as having the user specify the type of control to be added to a window.
The ISAPI provides a simple and efficient way to extend any ISAPI-compliant Web server. Using it, you can
write ISAPI dynamic link libraries (DLLs) that can be loaded and called by a Hypertext Transfer Protocol
(HTTP) server.
An ISA is invoked from a browser application and provides functionality similar to that of a Common
Gateway Interface (CGI) application.
ISAPI filters provide the capability of preprocessing and postprocessing of all data sent between the client
and the server.
The general nature of a program is to have a single thread of work occurring at one time. If we want to have
several things happening at the same time, we can start other threads.
a secondary thread is created to perform a specific task. The program causes a thread to be created when the
task is to be accomplished, and the thread goes away on its own once it has finished the work.
Active documents are actually standalone applications that can be hosted within a web browser.

Chapter 7: Creating and Managing COM
Components
Using the SDK.. 4
Using MFC.. 13
Using ATL. 15
Creating an ATL COM In-Process COM Component 17
Creating an ATL COM Out-of-Process COM Component 18
Using ATL. 20
Using the SDK.. 23
Using MFC.. 25
Aggregation versus Containment 27
Single-Threaded Apartment 38
Multithreaded Apartment 39
Both Single-Threaded and Multithreaded. 39
Two-Minute Drill 43
Creating a COM Component
Creating ActiveX User Interface Controls
Creating a COM Component Reusing Existing Components
Adding Error Handling to a COM Component
Logging Errors into an Error Log
Creating and Using an Active Document
Debugging a COM Component
Apartment-Model Threading
The Component Object Model (COM) is the brave new world of the programming future. The days
of writing an isolated application that does everything it needs to do by itself are being left to the
history books. The primary motivation for using COM is the ability to write some Thing once and use
it many times in different applications. Re-use. Leveraging your investments.
You wont read any code written in COM. COM is, as its name states, a model. It is a model to create
objects that have qualities or properties and that will do tasks for you. A rubber ball has properties; it
Chapter 07: Creating and Managing COM Components
is rubber, round, and may be red or blue. That same ball can accomplish tasks such as bounce off a
wall or roll on the floor or rise and fall in the air. These tasks that the ball can do are called its
methods.
COM addresses a group of major problems connected with sharing code between applications.
COM makes it possible to use something that was written in one language with an application written
in a different language. For example, I could write a component in Visual C++ and use it in Visual
Basic (VB), Delphi, Foxpro, or any other COM-enabled development tool. This is because the
component is already compiled and ready to execute. The user of the component does not need the
source code, they only need to know what the component is capable of. You will see how to get this
information later using a base interface, IUnknown.
Components that conform to the COM standard are reusable because they posses an interface. The
components implementation is purposely separated from the interface. The user of the component
does not need to know how the component does what it does.
One component can be used simultaneously by more that one application. The life of that
component is managed by the operating system. The component is removed from memory when it is
no longer in use by any application and not before. These same applications do not need to know how
to find the component and they do not need to worry about whether the component is already loaded
into memory.
COM components may be upgraded, enhanced, and changed without destroying the applications that
depended on an older version of the component. Not only can they be modified, but they are also easy
to distribute.
The COM specification is available for free from Microsoft. If you have Internet access you may
download it from http://www.microsoft.com/com/. It may also be found on the CDs distributed with
many of the books about COM or Distributed Component Object Model (DCOM) on the market.
Creating a COM Component
The evolution of COM has an interesting history, beginning with Dynamic Data Exchange (DDE)
and progressing to Object Linking and Embedding (OLE). DDE had a steep learning curve associated
with it. Applications using DDE were difficult to develop and to maintain. OLE was an attempt to
allow users to include a product of one software application in with another applications product. For
example, if a user wrote a letter to the boss using Microsoft Word, they may want to include a visual
chart representing some data from Microsoft Excel. Both of these applications are COM-enabled and
both were instrumental in the evolution of the existing implementation of Active documents.
What does ActiveX have to do with this? ActiveX is a marketing term or an umbrella term for a
collection of technologies. Two technologies in this collection are OLE documents and OLE servers,
or Automation servers. Microsoft is aware of the confusion caused by using the term server because
this term is also used extensively in the hardware-networking arena for a LAN server or a database
server or an Internet Information server. A name change was in order. Microsoft now encourages the
use of the term component to be synonymous with Automation server.
Another confusing term is client/server. In the networking arena, the meaning of this term may land
anywhere along the continuum from a workstation connected through a network interface card to a
network server, a database application providing data to a workstation, or an internet application that
is used to get database information. When using this term, one almost has to provide a definition to
ensure that the term is correctly understood.
In the COM world there is a precisely ambiguous definition for the term client/server. An application,
whether it is written as an executable (.exe) or as a dynamic link library (.dll), that may provide
services is a server. Any executable application that requests services is a client. And yes, an
executable application may be both a client and a server at the same time.
Appropriate analysis and design techniques are required before you attempt to develop a COM
component. In particular, the interfaces between your component and the client must be well defined
and generalized enough to enable reuse of your component in other applications, if necessary.
Remember that the ability to reuse your component will result in the greatest cost benefits.
Using the SDK
COM component development in Visual C++, with the aide of the Win32 software development kit
(SDK), is an exercise in patience and persistence. I am convinced that this activity builds character.
The developer then understands why COM works no matter what language the component is coded
in, C++, VB, or FoxPro. The effort to achieve this understanding may be greater than the effort
needed to understand how to create components using the Microsoft Foundation Classes (MFC) and
the Active Template Library, (ATL) combined. But when you are done, you will thank yourself. We
will explore the MFC and the ATL later in this chapter.
In and Out of Process
You know that every application that you run under Windows 9x or Windows NT runs in its own
address space. This protects your application from the oddities of other programs and it protects the
rest of your computer from the oddities of your application. If your application blows up mid-stream,
it will not hang up your computer or bring down any other applications. Windows gives each program
4GB of virtual address space. This is known as the programs process space. You can write a
component to run either in the same process space, known as in-process, or the component may be
written to run in its own process space, known as out-of-process, which also means that the
component may run as a stand-alone application. A great example of an out-of -process component is
Microsoft Word or Microsoft Excel. Both of these applications may be called by another application
to provide their unique functionality, that of word-processing or number crunching. The functionality
of Word or Excel may be provided within the other application. Out-of-process components are also
called local servers, meaning that they run on the same computer as the application that requested its
services.
Distributed components are these same components that are physically running in another computer
on the network. Distributed components are dealt with in another exam, 70-015: Designing and
Implementing Distributed Applications with Microsoft Visual C++ 6.0.
Component Communications
When an out-of-process server needs to respond to the requests of a client application, it uses a tool
termed lightweight remote procedure calls (LRPCs). RPC is a familiar term to most programmers
and LRPC is a smaller version specifically developed for COM. Com is implemented by a runtime
library which contains this functionality. Every time a client needs something from the server, Com
catches the request from the client and serves it up to the server in another process space by using
LRPC and another concept called marshaling.
Marshaling is the process of gaining access to another process address space. Marshaling creates a
proxy in the client to create to a stub in the server. This is how information is passed between
processes on the same computer. Marshaling enables location transparency. The client doesnt have
to worry about how to find the component, whether the component is loaded into its own process
space or on another computer altogether. The proxy contains a copy of the interface pointers of the
server. The stub, residing in the server, accepts the call through LRPC, and sorts out the pointers from
the parameters and makes the call to the method. Once the method is finished, it then repackages
everything and sends it back to the proxy in the client application. COM will supply the proxy and
stubs if you use the standard interfaces. If you want custom interfaces then you need to use a
specialized language called Microsoft Interface Definition Language (MIDL). Using MIDL, you can
optimize local and remote components.
The Windows Registry
The Registry on any computer is unique to that computer. You cannot take the Registry off of one
computer and copy it over the Registry of another computer. The Registry contains the identification
and other information about all the components located on that machine. Every component is
identified by a unique identification number. This number is called a globally unique identifier
(GUID), pronounced goo-id. This is a 26-byte series of numbers that includes the network card node
identifier of that computer as well as the current date and time and a combination of counters. The
class identifier and the interface identifier, which will be discussed later, are specialized GUIDs.
Lucky for us, we dont have to create our own GUIDs. Microsoft ships a GUID generator named
GUIDGEN. GUIDGEN has a visual interface, and its DOS counterpart, UUIDGEN, has a
command-line interface. GUIDGEN calls a COM application programming interface (API) function
CoCreateGuid(). If you accepted the default installation directories when you installed Visual Studio,
you can find GUIDGEN in the C:\program files\microsoft visual studio\common\tools directory. If
you installed only Visual C++, just change Visual Studio to Visual C++ in the directory path.
To find a server the COM runtime functions, check out a hive in the registry named
HKEY_CLASSES_ROOT\CLSID. This is also the location from which the COM Viewer gets its
information. When you write your component, you will be responsible for registering your
component and for providing a mechanism to unregister the same component. You may do this
manually, by using REGEDIT or you may make your component self-registering. If you make the
component self-registering, you use a command-line argument to register, /RegServer, or unregister,
/UnRegServer, the component.
Exam Watch: Make sure you know how to register your automation server by using all the different
methods. Also, make sure you understand how to register a new version of your server and your
custom ActiveX control.
Interfaces
In COM, the declarations of functions are separated from the implementation of those functions. The
implementation is contained in the class but the declaration is contained in the interfaces. An
interface is nothing but a pointer to a pointer to a class. The one interface that all COM components
must have is IUnknown. IUnknown is the base class for the new components interface. The
IUnknown interface provides three methods, QueryInterface, AddRef, and Release. QueryInterface
returns the information about whether a particular function exists. AddRef and Release manage the
lifetime of the component in memory. Several client applications may need to use a component at the
same time. When application A first invokes the component, it is loaded into memory, and one is
added to the reference count of the component. When application B invokes the component,
Windows knows that the component is already loaded into memory so it adds one to the reference
count to make the reference count two. Adding to the reference count is completed using the AddRef
function. When application A is finished with the component, Windows cannot unload the component
from memory because application B still needs it. Instead, Windows decrements the reference count
by one and waits until the reference count reaches zero before unloading the component. This activity
is managed by the Release method of IUnknown.
The application that I am using as an example is simple to the extreme. All it does is return the name
of a food which is randomly selected from a list of foods. It doesnt even have a fancy interface, it
simply opens a DOS window and spits out the name of a food. What you see in Figure 7-1 is what
you get. I have kept this simple because the focus is only on a component example.
Figure 1: The Foods application returns a randomly selected food name
The header module for my Food component interface, Ifood.h, is as follows:
#ifndef IFOOD_H
#define IFOOD_H
#include "FoodGuids.h"
DECLARE_INTERFACE_(IFood, IUnknown)
{
STDMETHOD(GetFood)(PBSTR) PURE;
};
typedef IFood* pIFood;
#endif
You can see, next to the DECLARE_INTERFACE macro, that the component inherits the IUnknown
interface. In the next line, you can see that my component has only one of its own functions,
GetFood.
The header module to my component, Food.h, then includes the Ifood.h file:
#ifndef FOOD_H
#define FOOD_H
#include "IFood.h"
class ComFood : public IFood
{
public:
ComFood();
STDMETHODIMP QueryInterface(REFIID, PPVOID);
STDMETHODIMP_(ULONG) AddRef();
STDMETHODIMP_(ULONG) Release();
STDMETHOD(GetFood)(BSTR*);
protected:
ULONG m_cRef;
};
typedef ComFood* PComFood;
#endif
In this header, the three functions belonging to Iunknown are listed as the first three and then my
components only function follows.
The implementation module, Food.cpp is as follows:
#include <string>
#include "Food.h"
#include "FoodFactory.h"
using namespace std;
static string g_strFoods[] =
{
"Apple",
"Lemon",
"Bread",
"Meat",
"Milk",
"Cheese",
"Popcorn",
"Carrots",
"Broccoli",
"Artichokes"
};
static const ULONG g_ulNumberofFoods = sizeof(g_strFoods)/sizeof(string);
ComFood::ComFood()
: m_cRef(0)
{
g_strFoods[rand() % g_ulNumberofFoods].c_str();
}
STDMETHODIMP ComFood::QueryInterface(REFIID rIID, PPVOID ppInterface)
{
if (rIID == IID_IUnknown)
{
*ppInterface = this;
}
else if (rIID== IID_IFood)
{
*ppInterface = this;
}
else
{
*ppInterface = NULL;
return E_NOINTERFACE;
}
((LPUNKNOWN) *ppInterface) -> AddRef();
return NOERROR;
}
STDMETHODIMP_(ULONG) ComFood::AddRef()
{
m_cRef++;
return m_cRef;
}
STDMETHODIMP_(ULONG) ComFood::Release()
{
m_cRef--;
if (m_cRef)
{
return m_cRef;
}
delete this;
return 0;
}
STDMETHODIMP ComFood::GetFood(PBSTR pbstrFood)
{
g_strFoods[rand() % g_ulNumberofFoods].c_str();
return NOERROR;
}
Class Factory
A class factory is the way that COM creates and destroys specific instances of components. In other
words, if your application needs to use a component, the application must first call the components
class factory to create an instance of that component. When you no longer need the component, then
you call the class factory to get rid of the component for you. Although a class factory is often called
a class object, it would make more sense if a class factory were called an object factory because it
does not create the template, the recipe, or the cookie-cutter, but rather the actual object to be used.
following is the class factory header module, FoodFactory.h:
#ifndef FoodFactory_H
#define FoodFactory_H
#include "IFood.h"
class ComFoodFactory : public IClassFactory
{
public:
ComFoodFactory();
STDMETHODIMP CreateInstance(LPUNKNOWN, REFIID, PPVOID);
STDMETHODIMP LockServer(BOOL);
protected:
ULONG m_cRef;
ULONG m_cLocks;
ULONG m_cNumObjects;
};
typedef ComFoodFactory* ptrComFoodFactory;
#endif
following is the class factory implementation module, FoodFactory.cpp:
#include <iostream>
#define INITGUID
#include "Utilities.h"
#include "FoodFactory.h"
#include "Food.h"
ULONG m_cLocks = 0UL;
ULONG m_cNumObjects = 0UL;
ComFoodFactory::ComFoodFactory()
: m_cRef(0)
{
VerboseMsg("HI!\n");
}
STDMETHODIMP ComFoodFactory::QueryInterface(REFIID rIID, PPVOID ppvInterface)
{
*ppvInterface = NULL;
if (rIID == IID_IUnknown)
{
*ppvInterface = this;
}
else if (rIID == IID_IClassFactory)
{
*ppvInterface = this;
}
else
{
return E_NOINTERFACE;
}
((LPUNKNOWN) *ppvInterface)->AddRef();
return NOERROR;
}
STDMETHODIMP_(ULONG) ComFoodFactory::AddRef()
{
m_cRef++;
return m_cRef;
}
STDMETHODIMP_(ULONG) ComFoodFactory::Release()
{
m_cRef--;
if (m_cRef)
return m_cRef;
/* Counters::DecObjectCount(); */
delete this;
return 0;
}
STDMETHODIMP ComFoodFactory::CreateInstance (LPUNKNOWN pUnkOuter,
REFIID rIID,
PPVOID ppvInterface)
{
PComFood ptrObj;
HRESULT hResult;
if (pUnkOuter && rIID !=IID_IUnknown)
return CLASS_E_NOAGGREGATION;
ptrObj = new ComFood;
hResult = ptrObj -> QueryInterface(rIID, ppvInterface);
if (FAILED(hResult))
{
delete ptrObj;
return hResult;
}
return NOERROR;
}
STDMETHODIMP ComFoodFactory::LockServer(BOOL fLock)
{
// Are we locking or unlocking?
if (fLock) {
// Locking
m_cLocks++;
}
else {
// Unlocking
m_cLocks--;
}
return NOERROR;
}
Using MFC
The MFC is commonly thought of as the tool of choice for creating the user interface oriented
windows-based application. But so much of COM support is embedded within the MFC that it can
greatly decrease the lines of code. There are MFC macros that replace chunks of COM-specific code.
During my discussion, I will refer back to the Food component and attempt to specify which lines in
which modules the MFC will eliminate or replace.
The MFC was originally named the Application Framework which is why you run into the acronym
AFX quite often. Distributed with Visual Studio or Visual C++ is the source code to the MFC. This is
located at C:\program files\microsoft visual studio\vc98\mfc\src.
The MFC class CCmdTarget is the source of the IUnknown functionality. This class implements
QueryInterface, AddRef, and Release. This is a small portion of what this valuable class can do for
you. It also contains support for critical message handling, automation, and basic windows graphical
user interface (GUI) elements. This class is in the AFXWIN.H header file in the c:\program
files\microsoft visual studio\vc98\mfc\include subdirectory, assuming that when you installed Visual
Studio, you accepted the default installation directories. The exact name of the methods to call are
ExternalQueryInterface(), ExternalAddRef(), and ExternalRelease(). The one small caveat here is that
because every class must implement IUnknown, you must redirect any class calls to these three
methods into the CCmdTarget external methods.
The MFC implements multiple interface inheritance through the use of nested classes. The MFC
macros BEGIN_INTERFACE_PART and END_INTERFACE_PART are actually class declarations.
The BEGIN_INTERFACE_PART needs the name of the class and the name of the interface class as
parameters. These macros are contained in the AFXDISP.H header file in the c:\program
files\microsoft visual studio\vc98\mfc\include subdirectory. What the END_INTERFACE_PART
does for you is make the class you want to nest a friend of the wrapper class so that the nested class
can access all data and methods of the outer class.
One of the major benefits of using the MFC is that it implements a class factory, the module
responsible for the creation and destruction of your component, for you. You wont need to write the
module FoodFactory.h.
The DECLARE/IMPLEMENT_DYNCREATE and DECLARE/IMPLEMENT_OLECREATE
macros actually create the implementation of the class factory. These are macro pairs that must work
together. The header file of your class needs the DECLARE_DYNCREATE and DECLARE
OLECREATE declarations and the code file of your class needs the IMPLEMENT_DYNCREATE
and IMPLEMENT_OLECREATE macros calls.
The class header module would include the following statements:
// Enable dynamic creation of the Class Factory
DECLARE_DYNCREATE(ComFood)
// Actually declare the Class Factory
DECLARE_OLECREATE(ComFood)
An interface map is table that has pointers to every interface implemented by a class. The Declare
macro is the declaration of this map and the Begin/End pair of macros are the wrappers for the actual
table. The DECLARE_INTERFACE_MAP MFC macro is needed in the header module and its
corresponding macros BEGIN_INTERFACE_MAP and END_MESSAGE_MAP macros are needed
in your .cpp module.
Using ATL
The Active Template Library (ATL) is a collection of prefabricated code for writing COM objects.
Many of its features are similar to the MFC and it has some additional advantages, but the basic
concept of the ATL, that of enabling accelerated C++ development, is the same as the MFC. When
you are considering writing components or controls that may be downloaded over the Internet, the
size of the resulting file becomes important. The ATL was created to specifically address not only the
size issue but also the speed of the resulting control or component.
Dual interface is a term that refers to the two ways that any component may be located once it is
loaded into memory. The Registry takes care of locating the executable for the operating system to
load but, once loaded, how does your client application find it in memory? One method is a virtual
function table (vtable). This is a series of pointers that specify the address of the objects method. For
example, my Food object had one method, GetFood, in addition to the three methods of IUnknown.
The vtable could be graphically modeled as in Figure 7-2.
Figure 2: Vtable mapping
IDispatch is the other way to find a component in memory. IDispatch, like IUnknown, is a standard
interface that the component author grows to know and love. Four methods are implemented by
IDispatch and are shown in Table 7-1. The dispatch identifier (dispid) is an integer that identifies the
sequence in the list of method addresses of the pointer to the corresponding method. So to use
Idispatch, one would first call GetIDsOfNames to get the dispid and then call Invoke which would
use the dispid to find the method and start it.
Vtable interfaces are faster, but automation interfaces are nice to have for those environments that
cant access the vtable interface.
Method Name Method Description
Invoke Invokes a components method
GetIDsOfNames Returns the dispatch id
GetTypeInfo Returns the pointer to ITypeInfo for the components type information
GetTypeInfoCount If the component has type information, this method returns a one.
Table 1: IDispatchs methods
The creation of low-level COM object with dual interfaces is greatly simplified by the ATL because
it also manages the proxy and stubs required for marshaling. Marshaling, you may recall from our
previous discussion, is the way COM enables cross-process communication through LRPC.
Whereas the MFC supports only apartment-model threading, ATL servers may use apartment-model
threading, free threading models, or both. Threading models are discussed later in this chapter.
Creating an ATL COM In-Process COM
Component
CWinApp is the base class for every MFC application. You may decide to create an in-process ATL
COM server that has MFC support. Because of this decision, you will get a larger application than if
you simply used the ATL without support for MFC.
The ATL has CComModule that is similar to CWinApp. If you want an in-process server though you
have to take care of your own messaging. The message loop is not provided for you in CComModule
as it is in CWinApp. This can be a good thing because you dont have to provide all the messaging
code, just the portions that your server cant serve withoutThe following are some of the tasks that
CComModule does provide for you.
Registers class factories
Registers the server
Unregisters the server
Manages server locks
Another class that is mandatory for an ATL component is CComObjectRoot. This is to ATL what
CCmdTarget is to the MFC. It controls reference counting. But, if you were to look for IUnknown in
the CComObjectRoot class declaration, you would not find it. IUnknown is in the CComObject class.
CComObject is a trick class. Unlike other classes, it is derived from the class that you create. Because
it is derived from your class, CComObject will provide the implementation of IUnknown and you get
to ignore it. Macros declare the aggregation of your component and define the implementation of the
CComObject class. These macros expand into a typedef. This typedef is for the constructor, which is
used to create instances of your class when the client calls CoCreateInstance() or
IClassFactory::CreateInstance(). There are four different macros for four different purposes, but they
all basically work the same way:
DECLARE_AGGREGATABLE (default)
DECLARE_NOT_AGGREGATABLE
DECLARE_ONLY_AGGREGATABLE
DECLARE_POLY_AGGREGATABLE
These macros all use the IUnknown methods contained in CComObjectRoot.
CComCoClass magically binds your class to the default class factory. No explicit coding is required
from you so long as this is one of the classes on which your component is based. Here again, there are
macros which expand into a typedef.
DECLARE_CLASSFACTORY (default)
DECLARE_CLASSFACTORY2
DECLARE_CLASSFACTORY_AUTO_THREAD
DECLARE_CLASSFACTORY_SINGLETON
After all of the base classes, the MIDL compiler will create interface classes based on your customer
interfaces. This is achieved by writing implementation code for each function declared in each
interface class.
Creating an ATL COM Out-of-Process COM
Component
Remember, an out-of-process COM component is an .exe. As such, you may run it without a client to
activate it. However, if you do intend to allow other applications to create an instance of an object
based on your component, you would be wise to test your components behavior with a client. A
local, out-of-process server must worry about one thing that an in-process server may ignore. The
local server must concern itself with whether its internal object count is zero. If it is zero, the local
server must bring itself down. This requires a CComModule subclass.
Creating ActiveX User Interface Controls
An ActiveX control must interact with its container using COM, specifically the IUnknown interface
and it must be able to register itself in the system Registry. Controls are similar to components in that
they may send and receive data from their container applications and do things for their container
applications. Therefore, controls have properties and methods just as components do. But
programmers also use the controls in their development environment and must be able to dictate how
the control will react in the application. Therefore controls must also have events.
There are three different kinds of properties, as shown in Table 7-2.
Type of Property
Type Definition
Ambient Items that affect the environment of the controls container
Control Values which define the control. These may be altered by the control.
Extended Values which define the control. These may be altered by the controls
container.
Table 2: Properties and their definition
On The Job: Remember that you must test your custom ActiveX controls behavior in two
environments. The first environment is the most obvious, the runtime environment after you have
used your control in a sample application. The second is the design-time environment. Other
programmers that will be using your control in their development efforts must be able to rely on its
correct behavior.
A controls base class, COleControl, provides two methods, and the control may provide custom
methods that may be used by the container. The two methods that ColeControl provides are
Refresh(), which redraws the control, and DoClick(), which activates the event invoked in response to
a click from the mouse button.
COleControl also supports a handful of standard events, Click, DblClick, KeyDown, KeyUp,
KeyPress, MouseDown, MouseUp, MouseMove, and Error. Events are messages sent by the control
to the container. The container may need to provide functionality for these events when they happen.
All properties, methods, and events of a control have an identification number called a dispatch
identifier (dispid). The dispid makes it possible for the control to use the properties, methods, and
events. When programmers use a control in a container application, they need to know what is
available to them to use. The dispids are referred to in a type library file (.TLB). The type library
enables other languages to do early binding to an object because the compiler knows what
functionality is offered by the control and the syntax of that functionality.
IDispatch is the interface that permits runtime binding of an OLE object. See Table 7-1 for the names
and definitions of the methods for IDispatch.
IDispatch::Invoke is the magician that permits your container application to start up any method of
the object, get a property of the object, or set a property of the object. This is done by passing the
identifying number, dispid, to IDispatch::Invoke. Please understand that the dispid of Object As save
method may be five, but the dispid of Object Bs save method may be nine. And the object that is not
concerned with persistent data doesnt have a save method. One of the major challenges in
Automation is finding out the exposed methods and properties of the object.
Using ATL
Exam Watch: Make sure you know the benefits of using the ATL for your ActiveX controls. Because
the ATL was designed to address the issues of a small size and fast execution, you may expect to see
a scenario question about whether to base a control on the MFC or the ATL.
Create a new project using the ATL COM AppWizard. Decide on a name for your project and specify
the directory to locate the project workspace. Make sure that you specify a .dll for this project. Then,
insert an ATL object by dropping down the Insert menu and choosing new ATL Object. In the dialog
box that is then displayed, Figure 7-3, select Full Control. A second dialog box, the controls
properties dialog, is then displayed, as shown in Figure 7-4.
Figure 3: Select the category and the type of object that you want to create
This dialog box is interesting because as you enter the Short Name for your ATL control, the other
text boxes fill in automatically.
Figure 4: After you complete the Short Name field, the ATL Object Wizard fills in the rest of the text
boxes
Click the Attributes tab to set the COM options for your control. Figure 7-5 shows the options set for
the ATimelyCrtl control. The apartment threading model is the default threading model for a full
control and is the better choice for this control, which uses in-place activation.
Figure 5: Select your ActiveX controls attributes
You do want to specify a Dual interface because the IDispatch interface is used by the container. The
Dual interface option button is the default. The Yes option button for the Aggregation group is the
default and for my control, unnecessary. I changed this to No aggregation. I also selected the Support
Connection Points check box because my control will activate events for the container.
Figure 6: Select the stock properties that your ActiveX control will support
Stock properties are those properties that most controls need to be concerned about. When creating a
control using the MFC, you can invoke the properties wizard at any time as you are developing your
control. This is not so with the ATL. This wizard is only shown while originally defining the control.
Using the SDK
Controls written without the MFC or the ATL may be highly-focused, fast, and without any
overhead. The downside is that without the MFC or ATL-enabling tools, you must worry about
communication from your control to the container. Three interfaces that you can use specifically for
this task are IOleControl, IOleControlSite, and ISimpleFrameSite.
The user interface at design time must support access to properties, specific support for
OLEIVERB_PROPERTIES (which displays the properties item on the containers menu),
manipulating through the list of properties, and property change notification messages. The two types
of properties available to ActiveX controls are ambient properties and extended properties. Ambient
properties provide environment values that apply to all controls of that type. It is the
IOleControl::OnAmbientPropertyChange that is called whenever an ambient property is changed.
Extended properties are those properties that the container provides for the control. These properties
look like native control properties. The method IOleControlSite::Get ExtendedControl allows the
control access to the extended property.
Refresh, DoClick, and AboutBox are the standard methods of controls.
A control must notify its container of the controls events, and the container must be able to respond
to these events, if needed. The four types of events that a control may support are listed in Table 7-3.
Type of Event Description
Request events A control requests permission from its client to do something by calling a
method in the outgoing interface, thus triggering a request event. The client
signals the control through a boolean, out-parameter in the method that the
control called. The client can thus prevent the control from performing the
action.
Before events A control notifies its client that it is going to do something by calling a method
in the outgoing interface, thus triggering a before event. The client does not
have the opportunity to prevent the action, but it can take any necessary steps
given the action that is about to occur.
After events A control notifies its client that it has just done something by calling a method
in the outgoing interface, thus triggering an after event. Again, the client
cannot cancel this action, but it can take necessary steps given the action that
has occurred.
Do events A control triggers a do event to allow its client to override the control's action
and provide some alternative or supplementary actions. Usually, the method
that a control calls for a do event has a number of parameters for negotiating
with the client about the actions that will occur.
Table 3: Control Event Types
Standard events that controls can support are Click, DblClick, KeyDown, KeyPress, KeyUp,
MouseMove, MouseUp, and Error.
Be aware that the control has the responsibility of drawing itself, and the controls container has the
responsibility to position and size the control.
Using MFC
To create the control, use the MFC ActiveX ControlWizard, as shown in Figure 7-7. Because most of
us are familiar with text boxes, I will base the control on the CEditBox class and give our text box
some custom functionality. Figure 7-7 shows how to base your custom class on another class. In the
second drop-down list box in Figure 7-7, you can see a selection of standard controls. In this
example, you would select Edit.
Figure 7: Use the MFC ActiveX ControlWizard to create your project
Figure 8: Use the ControlWizard to select the features that you want your control to have
Even though the custom component is based on a standard control class, the EDIT control is, in turn,
based on COleControl, which is based on COleControlModule, which is itself based on CwinApp. A
hierarchy model is provided in Figure 7-9.
Figure 9: The TxtBoxCon inheritance hierarchy
Creating a COM Component Reusing Existing Components
Components were devised to be reused. The ability to reuse what has already been written can result
in a massive savings of development dollars. By using functionality that has already been tested, you
only need to focus on testing the use of the component.
Aggregation versus Containment
Inheritance can be a wonderful thing, but it can also be taxing. Microsoft needed a concept that could
exploit the ability to write components that are extensible without the need for invasive maintenance.
Aggregation and containment both are similar to inheritance in that you can retain the original
functionality of a component, then add new functionality without trashing the original functionality.
The crucial difference is that with aggregation and containment only the interfaces are maintained,
not the functionality itself.
Objects already exist that have functionality defined. You create an object that needs the capabilities
of the existing objects. The existing objects can be bound together and placed inside your new object.
The new object can then also have capabilities unique to it. This is containment.
For example, my Food component has a useful method, GetFood. I could create a different
component, PackagedFood, that has a method called PercentOfMDR which returns the calculated
percentage of the Minimum Daily Requirements of each vitamin and mineral that a packaged food
contains. A packaged food is a combination of foods which have been prepared and perhaps
enhanced, such as Strong-Person Bread.
The interface module for Food is as follows:
#ifndef FOOD_H
#define FOOD_H
#include "IFood.h"
class ComFood : public IFood
{
public:
ComFood();
STDMETHOD(GetFood)(BSTR*);
protected:
ULONG m_cRef;
};
typedef ComFood* PComFood;
#endif
The interface module for PackagedFood is as follows:
#ifndef PACKFOOD_H
#define PACKFOOD_H
#include "IPackFood.h"
class ComPackFood : public IPackFood
{
public:
ComPackFood();
STDMETHOD(PercentOfMDR)(BSTR*);
protected:
ULONG m_cRef;
};
typedef ComPackFood* pComPackFood;
#endif
Either of these components may be used by clients separately or they both may be needed by a client.
Both of these components implement IUnknown. When the methods of IUnknown are called, which
IUnknown is used? One solution is to create a wrapper component that implements both Food and
PackagedFood.
A picture of the relationship between MenuItems, Food, and PackagedFood using containment is
shown in Figure 7-10. When MenuItems needs to use the Food method, GetFood, it forwards the
method to the contained Food. Likewise, if it needs to use the PercentOfMBR then the method is
forwarded to the contained component.
Figure 10: The MenuItems, Food, and PackagedFood components are using containment
Aggregation is slightly different. Whereas containment forwards the calls to the internal objects,
aggregation directly exposes the interfaces to the internal objects as though the capabilities were its
own. Look at Figure 7-11. Aggregation makes the inner contained components look like they were
actually part of the outer component, MenuItems. No forwarding of methods is done, the pointer
returned is the true pointer of the inner methods.
Figure 11: The aggregation of Food and PackagedFood
Adding Error Handling to a COM Component
The three interfaces used for error handling are in Table 7-4. Be very clear that with an automation
server you need to report errors, using ISupportErrorInfo, back to the container application. The
operating system creates an error object that supplies IErrorInfo and ICreateErrorInfo.
Interface Description
IErrorInfo Supplied with the Error Object by the Operating System.
ICreateErrorInfo Supplied with the Error Object by the Operating System.
ISupportErrorInfo Used by the Automation Server to manage errors and report
errors back to the container application
Table 4: Error Handling Interfaces
The Windows API CreateErrorInfo is the function that returns an error object to your server. It is the
servers responsibility to fill in the blanks with descriptive information about the error. Using
CreateErrorInfo you can insert a description, specify the path and context of the help file, and state
the GUID and the ProgID for the interface that contains the error definition. Once all of this
information is set, call SetErrorInfo by using QueryInterface to get the IErrorInfo interface. You have
to pass IErrorInfos pointer to Set ErrorInfo.
Logging Errors into an Error Log
The system error log under the Windows NT 4.0 operating system is the place for logging errors. Not
only is it already created for you but it is managed for you as well. The Service Control Manager
(SCM) is the Windows NT service that accomplishes this task. Three types of errors are logged into
the Windows NT Event Log. The Event Viewer, a utility program provided with Windows NT, can
be used to look at the information that was logged. The three types of errors are application errors,
system errors, and security errors. Our applications can use this error log for our own purposes. It
may be used as an aid in debugging and then used by the released application for other error logging.
Table 7-5 contains a list of the standard information kept in the error log.
Data Name Data Description
Date Date error happened
Time Time error happened
User User id that was logged on when error happened
Computer Workstation id on which the error happened
Event Type Informational, Warning, Severe, or Security
Source Name of the application that generated the error
Category User defined
Event ID The sequence number of the event that was added
to the event log
Description User supplied textual explanation. May be
localized
Event Data Any raw data to be used in problem resolution
Table 5: Error Log Data
Creating and Using an Active Document
Active documents are the remaining vestiges of OLE. The theory behind this is the reuse advocates
dream. You write applications that do one thing very well and then use that same application in other
applications that need that functionality. For example, spreadsheet tasks are aptly implemented by
Excel, but you are working in a Word document which needs background data and a line chart based
on that data. Although Word does have simple spreadsheet and graphing capabilities, you already
have the data entered into an Excel worksheet. Your choices, without OLE, are to re-enter the data
into Word, or copy and paste the Word text into Excel. With OLE, you can simply insert an OLE
object into your Word document, tell the application in what form the linked data should be used, and
then tell the file name. You then have a Word document with an Excel worksheet as part of the
document. To modify the Excel worksheet, all you have to do is click in the worksheet to gain access
to all of Excels functionality. That is the process in a nutshell. Yes, there is more to it than that and
we will explore the nuances in a moment. My point is that in the applications that you write, you can
do the very same thing: get all the functionality of an existing application simply by embedding an
OLE object.
There are two ways that one applications product may appear in another application. In the
preceding example, where you have an Excel spreadsheet inside a Word document, the spreadsheet
may be linked or embedded. If the spreadsheet is linked, then all that is contained in the Word
document is a reference to the spreadsheet. The upside to this approach is that the size of the Word
document is smaller and, if you make a change to the worksheet outside of the Word document, the
change is immediately reflected. The downside is that if you move the Excel worksheet to another
directory, the Word document will not be able to find it. You will have broken the link.
With embedded objects, the entire Excel worksheet would be copied into the Word document,
enlarging the final size and creating a copy of the Excel worksheet that can only be modified from
within the Word document. Any change made to the original worksheet is not reflected in the copy in
the Word document.
There are also two different ways to make the Excel application do its thing. You may use in-place
activation. What this means is that when the Word document is being edited and you double-click the
Excel worksheet, Excels menus merge with Words menu and it appears as one application. The fact
that the object has in-place activation is denoted by the hatched border around the object. Without
in-place activation, when you double-click the Excel worksheet, Excel starts up in a second window
and you can clearly see that there are two distinct applications running. This is the only way an
embedded object can run. A linked object may run in-place or in its own window.
The two interfaces, IOleObject and IOleClientSite, make in-place activation possible.
Using AppWizard to create an OLE component creates an application class, a main frame class, and a
view class. The menu for your component, IDR_SRVR_INPLACE, is the menu which may be
merged with the containers menu at runtime when it is using in-place activation. If it is running as an
embedded component, it will create a class named IDR_SRVR_EMBEDDED. If the container can
also execute as a stand-alone application, the menu will be IDR_MAINFRAME.
Replacing Cdocument is the ColeServerDoc which supports OLEs connection to the container and
interacts with the ColeServerDoc class. These two classes implement IoleObject, IdataObject,
IpersistStorage and IoleInPlaceActiveObject. The container hands off the interface pointers to these
classes.
To demonstrate a compound document we will create a simple application.
Exercise 7-1 Active Documents
This exercise is intended to give you a brief introduction to an Active document. If you start the
Visual C++ IDE, you may follow these steps to create the server. The screen shots show how you
should complete the screens that require information. For other screens that you encounter, just
accept the default selections.
Start the AppWizard, as shown here: 1.
Illustration 1
Change the selections to those shown in the following screen: 2.
Illustration 2
Step 2 of 6 asks for the type of database support. None should be selected. This is the default. 3.
In Step 3 of 6 you must click the Mini-server option button because the mini-server contains
just enough support for what we want the Active document to accomplish. See the following
illustration:
4.
Illustration 3
In the next steps, steps 4 and 5, simply accept the default. In step 6, shown in the following
screen, you see what files are generated for you.
5.
Illustration 4
Debugging a COM Component
There are several steps in the debugging process for an ActiveX component and the client that uses
the component. First, you must build both the client and the component with the debug compiler
option turned on to create the symbolic debugging information, set a breakpoint in the component,
then start the client under debug mode in the integrated development environment (IDE). Once the
component has been instantiated by the client, the load event has executed. If your breakpoint was set
in the load event then this is when you would hit the breakpoint. When you call the component, the
IDE spawns a second debug session for the component. You have to be aware of what component
methods are being called and set the breakpoint in those methods. An alternative is to set a breakpoint
in the client right before the component is called and then single-step into the component. You are
able to step into and out of as many components as you need to and you can step across remote
procedure calls as well. One advantage of this approach to debugging a COM component is that you
can investigate problems if the component does not start up or load properly. After you have built the
component with the debug parameter on, dont forget to register the component by running it.
Apartment-Model Threading
A process may have one thread or multiple threads. These threads are managed by the operating
system. It may look like multiple threads are running simultaneously but the process is implemented
by swapping threads at small intervals. A thread is a path of executing machine-level code. To
achieve high levels of performance, you may write your code so that multiple paths of code are
executing at what appears to be the same time. Within a single 4GB virtual address space of an
application there are areas of memory named apartments and it is inside these apartments that COM
objects code executes.
Single-Threaded Apartment
The single-threaded apartment (STA) model may provide one apartment in which all of the threads of
all the objects run. This makes life easy because no marshaling or cross-process communication is
needed. COM method calls are placed on the windows message queue. This is done so that the
operating system can attend to the calls one at a time. Legacy code often ignores threading altogether
and, by default, uses a single STA.
More sophisticated coding tactics use multiple STAs within a single process space. This can make the
application run faster.
An STA is started by CoInitializeEx(NULL, COINIT_APARTMENTTHREADED) and then shut
down by CoUninitialize(). COINIT_APARTMENTTHREADED is the default. If you omit this
parameter, you automatically use the STA model.
Multithreaded Apartment
The multithreaded apartment model does not synchronize COM calls on the windows message
queue. In fact this model calls COM components methods without placing the request on the
message queue. Only one MTA is allowed per process space, but all threads in each apartment are
allowed to communicate with each other without using marshalling. The MTA model runs faster than
the STA model because it does not have to toy with the windows message queue. The MTA simply
uses the vtable addresses to call a components methods. All serialization must be managed by the
programmer using mutexes or events, to protect shared memory or vmember data.
An MTA is started by CoInitializeEx(NULL, COINIT_MULTITHREADED) and shut down by
CoUninitialize().
Both Single-Threaded and Multithreaded
The Windows API functions that are used to manipulate threads are shown in Table 7-6. The
Microsoft Developer Network (MSDN) section for Visual C++ documentation has excellent sample
applications (these may be found under the MSDN directory \samples\vc98\sdk\com\tutsamp).
Function Name Description
CreateThread() Creates a new thread
SuspendThread() Pauses a running thread
ResumeThread() Restarts a suspended thread
TerminateThread() Kills a thread
GetExitCodeThread() Queries the exit code
ExitThread() Does not complete the thread function. Simply gets out of the thread
_beginthreadex() Creates a new thread but also starts up and shuts down the C runtime
library
Table 6: Thread Functions
From the Classroom
The Invaluable Variant Data Type
Through the experience of developing general use COM components, one of the data types with
which I have become very familiar is the VARIANT data type and its COM wrapper _variant_t. In
order to perform its magic, the Invoke method of the IDispatch interface relies on the use of the
VARIANT data type. Because using the VARIANT data type is invaluable and unavoidable when
doing any development of COM components, let's take a close look at it and its usage.
To put it simply, the VARIANT data type is a union of many different data types. A VARIANT
contains a data value and a value indicating the actual data type of the data. A VARIANT is 16 bytes
in size and is generally used to pass around arbitrary automation data. VARIANTs can contain most
primitive data types, strings, and arrays. However, it cannot contain fixed-length strings or
user-defined types. Here is what the declaration of the VARIANT data type looks like:
struct tagVARIANT
{
VARTYPE vt;
union
{
LONG lVal; //VT_I4
SHORT iVAl; //VT_I2
FLOAT fltVal; //VT_R4
DOUBLE dblVal; //VT_R8
VARIANT_BOOL boolVal; //VT_BOOL
SCODE scode; //VT_ERROR
CY cyVal; //VT_CY
DATE date; //VT_DATE
BSTR bstrVal; //VT_BSTR
IUnknown *punkVal; //VT_UNKNOWN
IDispatch *pdispVal; //VT_DISPATCH
SAFEARRAY *parray; //VT_ARRAY
SHORT *piVal; //VT_I2 | VT_BYREF
LONG *plVal; //VT_I4 | VT_BYREF
FLOAT *pfltVal; //VT_R4 | VT_BYREF
DOUBLE *pdblVal; //VT_R8 | VT_BYREF
SAFEARRAY **pparray; //VT_ARRAY | VT_BYREF
VARIANT *pvarVal; //VT_VARIANT | VT_BYREF
}
};
typedef tagVARIANT VARIANT;
The vt member of a VARIANT contains a constant (see the comments to the side of each member's
declaration) which indicates the data type contained by the VARIANT. So, a method that receives a
VARIANT parameter is able to parse the vt member to determine the actual type of the parameter.
Likewise, when creating a VARIANT, the data value, as well as a constant indicating the vt value,
must be set. The value of a VARIANT containing no data and no data type is indicated by the
VT_EMPTY constant.
There are several API calls available that help us deal with variant types. These API calls are:
VariantInit, which initializes a variant to VT_EMPTY; VariantClear, which initializes a variant by
freeing the memory used within the variant; VariantChangeType, which can convert the vt property
containing the data type of the variant variable to another data type this can throw an exception if
the coercion is not possible; and VariantCopy, which makes a copy of the variant and frees any
existing memory in the destination before making the copyit basically makes a call to VariantClear
before changing the vt value.
The last useful construct to look at when utilizing the VARIANT type in your COM components is
_variant_t. This construct encapsulates COM variant types and provides useful methods and
operations that make dealing with variants within your components much easier by handling resource
allocation and deallocation by calling VariantInit and VariantClear when required. Take a good look
at the VARIANT data type, and its COM encapsulation _variant_t, and use these constructs when
calling methods through the IDispatch interface.
Michael Lane Thomas, MCSE+I, MCSD, MCT, MCP+SB, MCDBA, MSS, A+
The topic of COM is of profound importance and you can be sure the exam will include extensive
coverage of the topic. Because ActiveX is an umbrella term there appears to be a mish-mash of
different concepts, but after studying ActiveX components, ActiveX documents, and ActiveX
controls, you begin to understand that the underlying enabler for all these concepts is one model and
that is COM.
For components, the major issues are whether they are in- or out-of-process, how they are registered,
and how the versioning is controlled. For ActiveX documents, the concept of in-place activation
versus a separate window is important, as is understanding the difference between linked and
embedded. ActiveX controls typically are downloaded and the distribution issues are extremely
important.
The best study aid is to write code using the concepts that have been covered in this chapter.
Two-Minute Drill
Components that conform to the COM standard are reusable because they posses an interface.
The components implementation is purposely separated from the interface.
ActiveX is a marketing term or an umbrella term for a collection of technologies. Two
technologies in this collection are OLE documents and OLE servers, or Automation servers.
Windows gives each program 4GB of virtual address space. This is known as the programs
process space.
When an out-of-process server needs to respond to the requests of a client application, it uses
a tool termed lightweight remote procedure calls (LRPCs).
Make sure you know how to register your automation server by using all the different
methods. Also, make sure you understand how to register a new version of your server and
your custom ActiveX control.
The MFC was originally named the Application Framework which is why you run into the
acronym AFX quite often. Distributed with Visual Studio or Visual C++ is the source code to
the MFC.
One of the major benefits of using the MFC is that it implements a class factory, the module
responsible for the creation and destruction of your component, for you.
The Active Template Library (ATL) is a collection of prefabricated code for writing COM
objects.
CWinApp is the base class for every MFC application.
An ActiveX control must interact with its container using COM, specifically the IUnknown
interface and it must be able to register itself in the system Registry.
Stock properties are those properties that most controls need to be concerned about.
Without the MFC or ATL-enabling tools, you must worry about communication from your
control to the container. Three interfaces that you can use specifically for this task are
IOleControl, IOleControlSite, and ISimpleFrameSite.
Aggregation and containment both are similar to inheritance in that you can retain the original
functionality of a component, then add new functionality without trashing the original
functionality.
The system error log under the Windows NT 4.0 operating system is the place for logging
errors. Not only is it already created for you but it is managed for you as well.
With OLE, you can simply insert an OLE object into your Word document, tell the
application in what form the linked data should be used, and then tell the file name.
There are several steps in the debugging process for an ActiveX component and the client that
uses the component. First, you must build both the client and the component with the debug
compiler option turned on to create the symbolic debugging information, set a breakpoint in
the component, then start the client under debug mode in the integrated development
environment (IDE).
A process may have one thread or multiple threads. These threads are managed by the
operating system.
The single-threaded apartment (STA) model may provide one apartment in which all of the
threads of all the objects run.
The multithreaded apartment model does not synchronize COM calls on the windows
message queue.

Chapter 8: Creating Data Services
Implementing Persistence Using CFile. 2
Display Data Using CArchive. 4
Implementing Standard Serialization Using Serialize. 5
Connecting a Recordset to Dialog Box Controls. 11
ODBC.. 19
DAO.. 30
OLE DB.. 33
ADO.. 35
RDO.. 38
Data-Source Control 39
Two-Minute Drill 48
Displaying Data from a Data Source
Accessing and Manipulating Data Using Ad Hoc Queries
Handling Database Errors
The purpose of this chapter is to discuss database programming. We will cover how to display data using the Microsoft Foundation
Classes (MFC) for file and database support. We will then explore various methods for retrieving and modifying a database with
the popular data access methods used in Visual C++. Visual C++ offers a wide range of methods for retrieving data and offers
wizards to help you use these methods with ease in your application.
These wizards will help you design your database application quickly and efficiently, requiring slight modifications to produce a
basic useable product. In this chapter we will look at the relevant classes and wizards that you can use to construct a database
application and provide comparisons and differences between the data access methods available.
Displaying Data from a Data Source
This section will cover the classes used in MFC to obtain data from a data source. CFile is a direct method of file input/output
(I/O). CArchive is a great class to use in a document/view application for file I/O because it makes use of the Serialize virtual
function. The catch is that the object must be derived from a CObject to support serialization. We will see how to use each of these
in a moment.
We will learn how to connect a recordset to dialog box controls using record field exchange (RFX). This will prepare us for the
next section which explains database access and management with Visual C++.
Implementing Persistence Using CFile
CFile class will let you directly access file I/O on the disk for persistent storage. This is the base class in MFC for many useful file
operation classes including CStdioFile, for plain text management, and CMemFile, used for temporary storage for fast transfer of
raw data. A CFile is a class that is a handle to a binary file; this differs from the win32 fopen() set of functions, which provide a
pointer to the file.
Using CFile on the stack is convenient when trying to read quickly from a file. When it is called on the stack, the constructor will
open the file and the destructor will close it automatically. Let us now take a look at a CFile call which will read from a file held in
the CString variable szMyFile. We will be reading 256 bytes from this file. A CFile read operation will return the number of bytes
that were read successfully.
int cbReadSize=0;
char szBufferRead[256];
if(myFileRead.Open(szMyFile, CFile::modeRead) //opens file for read only access

{
cbReadSize = myFileRead.Read(szBufferRead, sizeof(szBufferRead));
if(cbReadSize == 256))
{
MessageBox (All Data Succesfully Read);
} else
{
return FILE_NOT_ALL_READ; // User defined constant
}
} else
{
MessageBox(Could not open File);
}
Here we checked to see if we could open the file with a CFile::Open command that returns nonzero if the file is opened
successfully or zero if the file could not be opened. Next we perform the actual read from the file. We tell CFile::Read that we are
storing in szBufferRead for the size of the array of szBufferRead (which happens to be 256). A message box will alert you if all the
data was read correctly. If not, FILE_NOT_ALL_READ is returned to the calling function for error handling (note:
FILE_NOT_ALL_READ should be defined in a header file).
CFile offers many functions for writing, reading, and traversing the files. You can find a complete listing on your Microsoft
Developer Network (MSDN) CDs. We dont use CFile for database file operations, later we will see how to handle database file
I/O.
When using the document/view architecture, you can avoid using CFile through CArchives file serialization techniques. CArchive
is on a higher level than CFile. Serialize manages the CFile connection to the persistent file on your storage medium while the
CArchive buffers the data for that CFile object. Over the next two sections we will go through the concepts of this strategy more
thoroughly.
Display Data Using CArchive
CArchive is used mainly for saving objects to a binary form that will remain accessible even when those objects are deleted in the
program. CArchive doesnt have a base class, although you are free to derive classes from it. CArchive is used after a CFile object
is created. When using the document/view architecture, the framework will create both the CFile object and the CArchive object.
The CFile object will handle the actual writing to the disk and the CArchive object will buffer the data, differentiate between
different schema, and keep track of the file I/O state. A schema is used for versioning. We will cover this topic with serialization.
The two purposes of CArchive are for serialization and for supporting MFCs CSocket and CsocketFile classes. We will discuss
some background on the CSocket classes here to bring you up to date before discussing socket serialization. CSocket is a higher
level of abstraction for CAsyncSocket. Using CSocket alone as a simple substitution is possible, but using it with CArchive is
recommended. CSocket is derived from CAsyncSocket and provides communication with various socket protocols such as
winsock. WinSock is short for windows sockets and is based on Berkeley sockets for communication over networks in windows.
Communicating over a socket requires a server and a client in most cases, although sometimes there are peer-to-peer socket
connections. The basic format for the connection to a server is to listen, respond, and close the connection. The format for the client
connection is to connect, listen, respond, and disconnect. A practical use of this will follow in the next section, but first we have to
go over the basics.
Implementing Standard Serialization Using Serialize
In the document/view architecture, MFC supplies you with the convenient CArchive and CFile classes with the framework. When
using the application wizard in Visual C++, if you choose a single-document interface (SDI) or a multiple-document interface
(MDI) in step 1, as shown in Figure 8-1, Visual C++ will lay out support for serialization. Well talk a little bit about what MFC
does for us, then we will take a custom class and show what we have to do to have a completely functional serialization example.
Figure 1: In Step 1 of the MFC AppWizard, you choose the type of application that you want to create
Now that you are familiar with the CFile and CArchive classes, it is time to see how to use them for quick file I/O with
serialization. Serialize is a virtual function in the MFC library. MFC provides you with a menu bar in a document/view application
that supports the File Save and File Open commands. These menu choices will call the applications serialize function.
Serialization is a way to stream data to and from a persistent file.
Now lets look at the first thing MFC generates for us when we choose an MDI or an SDI. MFC gives us the declaration for the
virtual function in the document header portion. This takes in one parameter, a CArchive reference that is named &ar by default.
This file in the underlying MFC framework interfaces with a CFile object to actually read or write to the disk. In the
implementation file is the function CDocument::Serialize. This function has a simple ifelse statement that calls the
CArchive::IsStoring function to determine whether to stream to or from a file. Lets look at some code and then we will go over the
specifics.
Class CPayroll : public CObject //derive from CObject to support Serialization
{
DECLARE_SERIAL (CPayroll)
private:
int m_hours, m_overtime, m_employeeID;
CString m_szName;
public:
CPayroll () {} //default constructor
CPayroll (int employeeID, int hours, CString szName);
~CPayroll() {}
void Serialize (CArchive&); //function override
int GetHours();
void SetHours(int);
int GetEmployeeID();
void SetEmployeeID(int);
int CalculateOvertime(int hours);
CString GetEmployeeName();
void SetEmployeeName(CString);
}
We have started adding serialization support. This will be a class declaration in the document header file. First, we have derived
this from a CObject class; this will inherit Cobjects support for serialization. Next you will see the DECLARE_SERIAL macro;
this is required for the serialization process. The class also overrides its base class Serialize member function in order to persist
this object to disk. One important thing to mention is the need to have a empty constructor, as you can see in the preceding code.
Now we are halfway there and all we have to look at is the implementation file. This consists of using the IMPLEMENT_SERIAL
macro and the actual storage routine. We will lightly touch on versionable schema and leave a more thorough explanation for later.
The first thing we would like to add to the document implementation is the following:
IMPLEMENT_SERIAL (CPayroll, CObject, 1)
This takes the class that we are adding serialization to, the class it is based on, and the schema number. The following is a sample
of the serialization function:
void CPayroll::Serialize (CArchive &ar)
{
CObject::Serialize (ar);
if (ar.IsStoring())
ar << m_hours << m_overtime << m_employeeID;
else //is loading
ar >> m_hours >> m_overtime >> m_employeeID;
}
In the preceding example, the serialization function will call the base class serialize function only for good practice. Although it
isnt necessary here, it is called in case the base class had contained other data members that would need serialization. CArchives
member function IsStoring is called in order to determine whether we are writing to or reading from the archive. The appropriate
action is then taken for streaming data with the << and >> operators. These operators are inherited from the CArchive class and are
overloaded to work with the following data types.
CObject* SIZE CSize float
CString POINT CPoint DWORD
RECT CRect double LONG
CTimeSpan int BYTE WORD
COleDateTimeSpan COleVariant COleCurrency CTime COleDateTime

Another way a document may be serialized is a direct call to the Serialize function. This is useful when you dont have a
document/view architecture set up for your program (which means choosing a dialog-based application, as shown in Figure 8-1).
When you choose this route you will need to handle what MFC usually takes care of for you, but dont worry its a snap! First we
want to make a CFile object on the stack. Next, we create a CArchive object on the stack. Remember, when an object is created on
the stack it wont need to be deleted because it will be deleted when the function goes out of scope. As of right now this should
look familiar from what we have learned about how MFC handles serialization using the document/view architecture. The final
step will be the actual call to the objects Serialize function. Here we will use the class CPayroll from the preceding code and the
instance of it is called roster.
CFile tempFile;
if (tempFile.Open (ThisFile.prl, CFile::modeCreate | CFile::modeWrite))
{
CArchive ar (&tempFile, CArchive::store);
roster.Serialize (ar);
This opens the file, ties the archive to the file, and then serializes it to the file with the Serialize call. There is no need to close the
file as that will be taken care of when these objects go out of scope. Optionally, you may close them if you like. That will cover our
normal serialization methods and we will move on to talk about versioning an archive.
We will modify some of the earlier code snippets to support a new schema, which will write the employee name variable to the
archive. That isnt anything different from what we have been doing, but we will also allow for it to read an archive with and
without this variable included using a technique called versionable schema. For example, if you write an upgrade to your software
and it needs to save information to the archive that wasnt originally in the persistent file, serialization will still work and will read
the old format as well. Here we will teach you how to use a schema by adding the employee name into the archive. The class
header will remain unchanged and you may see that again above. However, the implementation file where we used the macro to
implement serialization will need some modifications. Dont worry; most of the details of versioning are again handled by MFC.
First, we want to change the macro to include the constant VERSIONABLE_SCHEMA as follows:
IMPLEMENT_SERIAL (CPayroll, CObject, 2 | VERSIONABLE_SCHEMA)

We then modify the Serialize function in order to check for the version number. This is accomplished with a
CArchive::GetObjectSchema call and by using the correct version extracted from it. Rather than cascading ifelse statements to
make the code more forward compatible, we will use a switch statement for each version. This way if another version is made,
plugging it into the switchcase loop is an easy task. We will be using some of the code from earlier, but will include the full
Serialize function here in its new form.
void CPayroll::Serialize (CArchive &ar)
{
CObject::Serialize (ar);
if (ar.IsStoring())
ar << m_hours << m_overtime << m_employeeID << m_szName; //storing new file
else //is loading check schema
{
int schemaversion = ar.GetObjectSchema(); //retrieve files version
switch (schemaversion) //check version number

{
case 1: //first version
ar >> m_hours >> m_overtime >> m_employeeID;
break;
case 2: //current version
ar >> m_hours >> m_overtime >> m_employeeID >> m_szName;
break;
default: //not a known version
MessageBox(Incorrect File);
break;
}
Here we have concluded serialization for disk files; which is the most commonly used serialization. In the code, you can see the
usefulness of CArchive::GetObjectSchema in versioning. We store the value returned to use in the switch statement to determine
which version the serialization is dealing with. We then take the appropriate course of action for reading the file. If the schema
doesnt match the available versions, we will use a message box to let the user know.
We have covered the serialization to an archive and are ready to dive into serializations role in dealing with CSocket. We wont be
covering this in much depth, but will familiarize you with some of its concepts. CSocket can also use CArchive to serialize data
across a socket. The MSDN library uses the PacketSerialize function to exchange data over a socket. This function takes in three
parameters: nPackets, for keeping track of the amount of packets; arData, for sending data outward over the socket; and arAck, for
receiving data from the socket. The difference here is we would like to include support for adding a header to the file ( and reading
the header), checking how much data was sent (and how much data was received), and receiving an acknowledgement (and
sending an acknowledgement). When using serialization over sockets with MFC, make certain the server knows the MFC objects
that it will be receiving. It mainly works like the serialization process we have seen so far and I will leave it up to you to discover
the rest.
Connecting a Recordset to Dialog Box Controls
MFC connects your recordset to dialog box controls with record field exchange (RFX) and with dialog data exchange (DDX) in a
two-step process. RFX binds member variables to fields in the database whereas DDX transfers data between dialog box controls
and the member variables. First we will cover RFX, which will bind the fields to the variables, then we will take these variables
and see how MFC binds them to the dialog controls with DDX.
RFX binds the fields from your database into your variables once you choose your data source and are using MFC. We will be
creating a sample database in Microsoft access for use in the next section and RFX will be described in more detail there as well,
but for now I will show you what a sample RFX command looks like in the MFC function DoFieldExchange.
An RFX command will first take a SetFieldType function to tell the compiler that you are using input parameters, output
parameters, or columns. Then when binding a control to a member variable, MFC calls one of the RFX macros depending on which
type of data is in the field. A listing of these types are shown in Table 8-1. These macros take three arguments. The first argument
is a pointer to a CFieldExchange object. The next argument is the field name from the database. The final field is the member
variable to which the data source field will be bound. MFC will generate these bindings in the DoFieldExchange function that is
derived from CRecordSet . The reason we took a look at these was to familiarize you with them in case there is something you will
need to modify.
Macro MFC Type ODBC Type(s)
RFX_Text CString SQL_VARCHAR, SQL_DECIMAL, SQL_NUMERIC,
SQL_CHAR, SQL_LONGVARCHAR
RFX_Bool BOOL SQL_BIT
RFX_Long Long SQL_INTEGER
RFX_Int int SQL_SMALLINT
RFX_Single float SQL_REAL
RFX_Double double SQL_DOUBLE
RFX_Date CTime,
TIMESTAMP_STRUCT
SQL_DATE, SQL_TIME, SQL_TIMESTAMP
RFX_Byte BYTE SQL_TINYINT
RFX_Binary CByteArray SQL_BINARY, SQL_VARBINARY,
SQL_LONGVARBINARY
RFX_LongBinary CLongBinary SQL_LONGVARBINARY, SQL+LONGVARCHAR
Table 1: RFX Macro Types
We will take a break right here and build a simple database in Access. We will be using this database extensively later in this
chapter, so keep it handy. First, open Microsoft Access; if you do not have Microsoft Access you may skip to the next paragraph.
We will create our database step by step here.
Open Access and choose the Blank Database option on the screen that appears and click OK. 1.
Type payroll.mdb for the name in the Save As dialog box and click OK. A dialog box appears, as shown in Figure 8-2. 2.
Figure 2: Choose the method that you want to use to create a database table
Now click Create table in Design view. This will open an empty database table, as shown in Figure 8-3. 3.
Figure 3: Enter some values for the fields in this empty database table
We will now enter some values for fields, as shown in Figure 8-4. 4.
Figure 4: You should designate one of the fields as the primary key for this database
Make the employee ID field the primary key for this database by clicking to the left of the field so that the whole field is
highlighted, then right-click and choose Primary Key. A primary key is a field that will be unique; you can see the key
shown in Fig-5.
5.
Choose File Save and a dialog will pop up asking what to save the table as. Type byEmployee and press Enter. 6.
Create a new table like you did in Step 3 and Figure 2 and fill in the fields as shown in Figure 8-5. Save this table as
bySeniority.
7.
Figure 5: Fill in the fields in your bySeniority table as shown
Fill in some values for the bySeniority and the byEmployee tables.(note: make sure the employeeID starts with 1). 8.
Now we will create a query. To do this click Queries and double-click create Query in Design view. Highlight both fields
and choose Add then click Close. Double-click the star in the byEmployee table; this will add all the fields. Now
double-click the employeeID field. We need to modify this field in the lower portion of the form. Clear the box so that it
wont be repeated and choose Ascending for the sorting option. Now we will double-click the following fields in the
bySeniority table: DateofHire, Department, and vacationtime. Click the red exclamation point on the toolbar to run the query
9.
and make sure it is functional. Save this query when you are satisfied with the way it is running.
When you tie this database into your application, MFC will look at the fields and decide which RFX macros to use and will help
you create member variables to hold the database fields in member variables. DDX will connect dialog box controls to the database
fields and will handle the passing of data between them. DDX occurs in the view class with the function that we inherit,
CWnd::DoDataExchange. We pass data between these with the UpdateData() function. This function takes one parameter, a
Boolean value. UpdateData() will take TRUE when passing information from the form into the variables and FALSE when passing
information from the variables to the form. We will see more of these when we go over some practical examples in our next
section.
Accessing and Manipulating Data Using Ad Hoc Queries
In the business area, it is becoming increasingly necessary to store and retrieve data. One choice we have is to store it in a database.
Storing data to a database provides for a logical grouping of data. This also gives us the chance to perform queries to group data in
a variety of ways for viewing. Microsoft provides us with a few different choices on how to communicate with databases. Each has
its own unique methods to communicate and manipulate data in the databases. Because they have their own ways of doing things,
there are times when there are advantages to choosing one method over another. Here we will get a short introduction to the
technologies that Microsoft provides us with, then we will break each one down into its own section where we will go into more
detail and show some practical examples.
We will start with open database connectivity (ODBC). This technology is rather old, but has a large following due to its
compatibility with many data sources. We, as programmers, are trying to move away from ODBC in favor of the newer
technologies. The reason for its compatibility with so many database management systems (DBMS) is that the manufacturer will
include a driver for ODBC. There are other problems when using ODBC with VC++ that we will look at in the next section.
Next, we have Data Access Object (DAO), which uses the Microsoft Jet database engine. Microsoft Access uses this technology.
This technology is rarely used anymore in favor of the next few methods we will discuss. One main purpose of this technology is
MFC provides classes to interface with the Access .mdb files. A main problem with DAO in todays business applications is that it
doesnt support remote data sources. With companies increasingly relying on the Internet and using an intranet to maintain a
similar user interface, they need remote data access. We will cover how to use DAO in VC++ because it is a good choice for a
simple database application on one machine.
OLE DB uses Component Object Model (COM) to interface the databases. Using COM to interface databases provides us with a
unique opportunity to keep the data access language independent. Using Distributed COM (DCOM), we can access databases on a
remote server. This is event-driven programming, as any COM is. An example of such an event is the signaling of an error in the
database. This is used as a low-level access to data and is wrapped by ActiveX Data Objects (ADO). OLE DB and ADO are what
Microsoft would like to use to replace ODBC with gradually. You can use OLE DB as a full replacement for ODBC, because
Microsoft has included an OLE DB provider for ODBC. We will touch on this and describe what providers are a little later.
ActiveX Data Objects (ADO) are one of Microsofts newer technologies that make it easier to work with OLE DB. This actually
wraps OLE DB much like MFC wraps the windows application programming interface (API). ADO is also the primary means for
Visual Basic to access OLE DBs functionality and an easier method for VC++ programmers to use. ADO involves the use of
Active Template Library (ATL). We will see this in use a little bit later.
the last access method for us to use is Remote Data Objects (RDO). This is one of the newest data access technologies to Microsoft
Visual C++. RDO is the equivalent of an updated DAO to support remote access to data sources. You may actually use DAO calls
supplied with updated RDO commands to make use of RDO in VC++. It may also access ODBC directly, unlike DAO. RDO is a
great method for reducing traffic on a network while accessing your data efficiently. Some database servers arent equipped with
the functionality to handle a large volume of traffic and we will see how RDO can be used to help this situation.
Now that we know what is available to us, it is time to take a breather and prepare to explore these in a lot of detail and how to use
these with Visual C++. We will summarize some general rules for when to use each technology. Be warned that there are no set
rules for this, these are only basic guidelines. We will start with Microsofts oldest technology for accessing database files, ODBC.
ODBC
As you have seen, ODBC is falling from grace because of its slowness and the fact that deploying an ODBC application is rather
difficult because of the registry entries that need to be made to add a database to the ODBC driver. This isnt the easiest method to
use in the VC++ environment, but it also isnt the most difficult. We will be making use of the database that we created earlier to
follow through and create a simple sample application to show you how ODBC is used in VC++.
First, we want to set up the connection to the data source name (DSN) in the ODBC control panel.
Exercise 8-1 Setting up the connection to the DSN
Launch control panel and double-click the ODBC Data Sources (32-bit) icon. 1.
A dialog box will pop up. Among the choices, you can create a User DSN, for one user to access the data; a System DSN,
where anyone will have access to it; or a File DSN, where the users who share the directory will have access to it. A system
DSN will suit us well for the example so click that tab.
2.
Click Add, and the Create a New Data source dialog box will appear, prompting you to choose a driver. Take a moment here
to view all the support that ODBC has for different DBMS. We made the database in Microsoft Access and we want to
choose that as our driver. Click finish.
3.
A setup dialog box will appear. From here we can select the database we created by choosing select. Now navigate to the
directory where you saved Payroll.mdb and choose it.
4.
Now we want to type a DSN and a description. You can see from Figure 8-6 how I filled in these fields. 5.
Figure 6: Name the data source and provide a description of it in the ODBC Microsoft Access Setup screen
Choose OK and OK again. Now you are ready to use VC++ to connect to this database. 6.
We will create a form view application to see the results of our connection to the database. Start VC++ and create a new
application. This will deploy the AppWizard. Follow the next sequence of events to get on our way.
Exercise 8-2 Creating a form view application
Type an application name. Here I used AppODBC1. Select MFC Appwizard and choose OK. 1.
We will be using a single document so choose this and click next. 2.
We want to choose a database with file support here and then click the Data Source button. 3.
A new dialog box will appear. It should have options for which kind of database support you want. Leave this at ODBC and
choose AppODBC1 from the combo box. (This is the ODBC connection we created earlier from control panel). A recordset
is a set of records retrieved from the data source. CRecordSet encapsulates recordsets for ODBC. You wont deal with
CRecordSet in this example. You can use CRecordSet directly when you are using a parameterized query or a join. One last
option here is choosing between snapshot and dynaset. We will use dynaset because we will want to see changes as they are
made. A snapshot is like a photograph; it keeps a copy of the data when the query was run until you call Requery(), which is
like taking a new photograph. Click OK. The database tables dialog box will appear to enable you to select one.
4.
Select the LongForm and click OK. This is the query that we created in Access. Click OK again to go back to the
AppWizard where we left off.
5.
Click Next until we get to Step 6 of 6. Note the classes MFC creates for you. 6.
Click Finish then click OK. We are now ready to build your MFC database compatible program using ODBC. 7.
Lets take a second here to go over some of the database options you could have chosen in step 2 of the AppWizard. You can
choose to have no database support. Most applications may eventually need database support, so it might be a wise choice to
include some database support here because integrating it later is difficult. Another choice we have here is for header files only. If
you dont know what kind of database support might be needed down the road or just to be safe in case a possibility exists of
adding database support, this option is definitely your friend. This will include the headers for database support and it will be up to
you to create the classes. The last option that we didnt chose is database view without file support. This will create the classes for
you to access your database, but will not let the user select extraneous files with the File | Open command. The option we chose
was database view with file support. This gives users complete reign over the application. They can access other files besides the
data source that is built into the application. You will need to implement support for these files.
With that out of the way we need a way to display our database to the user. Click the AppODBC1Set.cpp and notice in the
DoFieldExchange function that MFC has created variable names for the fields. Later, we will see how to use these names for the
form controls for DDX. With that, we go to the form in resourceview. Remove the TODO static text from the form. Now we will
add controls for all the fields. Add seven edit controls. You may lay out the dialog however you please. My example is shown in
Figure 8-7. Set the ID values for the edit controls to the following: IDC_EMPLOYEE_ID, IDC_HOURS, IDC_NAME,
IDC_OVERTIME, IDC_DATE_OF_HIRE, IDC_DEPARTMENT, and IDC_VACATION_TIME. Now we will see an MFC
convenience: press the ctrl key and double-click the Employee ID control. notice the member variable name begins with
m_pSet->m_Department. Now move down the list box and match up the Employee ID variable with the edit field you have
clicked. Do this for the rest of the fields except for the date of hire control. This works for many variable types, but not for dates.
The data types for these fields should be CString for IDC_NAME and IDC_DEPARTMENT and long for the others. For now, we
will not fill the date of hire control.
Figure 7: Use this form as a guide when you lay out your form for displaying recordsets
Now we will go and look at the view portion of the program in AppODBC1View.cpp. Scroll down to the DoDataExchange
function. See how MFC connected the controls with the member variables for updating, with the exclusion of the date of hire field.
We will get to that in a moment, but first I want to show you how much work MFC has done for us. Compile and run the
application. Notice how you have a mostly functional database application. The next few things we will need to implement are
support for the date of hire field, support for adding a record, and support for searching the database.
Exam Watch: Many people confuse DDX and RFX during the exam. remember, DDX is used to transfer data between dialog
controls and member variables, whereas RFX associates recordsets with member variables, passing no data between them.
Let us start by adding support to the date of hire field. DDX isnt directly compatible with the date. we will add a member variable
for the date of hire field from classwizard. I called it m_date_of_hire. Now in the AppODBC1View.cpp file, we will add support
for this date field. We will use the following code snippet to get the date value and change it into a string.
void CAppODBC1View::DoDataExchange(CDataExchange* pDX)
{
m_date_of_hire = m_pSet->m_DateofHire.Format ("%B %d, %Y");
//new member variable m_date_of_hire
// takes in the formatted string from m_pSet->m_DateofHire which is contained in
//AppODBC1View.cpp and AppODBC1View.h
CRecordView::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAppODBC1View)
DDX_Control(pDX, IDC_EMPLOYEE_ID, m_oemployeeID);
DDX_Control(pDX, IDC_SUBMIT, m_oSubmit);
DDX_Control(pDX, IDC_CANCEL, m_oCancel);
DDX_Control(pDX, IDC_DATE_OF_HIRE, m_odate_of_hire);
DDX_Control(pDX, IDC_DEPARTMENT, m_oDepartment);
DDX_Control(pDX, IDC_HOURS, m_ohours);
DDX_Control(pDX, IDC_NAME, m_oName);
DDX_Control(pDX, IDC_OVERTIME, m_oovertime);
DDX_Control(pDX, IDC_VACATIONTIME, m_ovacationtime);
DDX_Text(pDX, IDC_DATE_OF_HIRE, m_date_of_hire);
DDX_FieldText(pDX, IDC_EMPLOYEE_ID, m_pSet->m_employeeID, m_pSet);
DDX_FieldText(pDX, IDC_HOURS, m_pSet->m_hours, m_pSet);
DDX_FieldText(pDX, IDC_NAME, m_pSet->m_Name, m_pSet);
DDX_FieldText(pDX, IDC_OVERTIME, m_pSet->m_overtime, m_pSet);
DDX_FieldText(pDX, IDC_DEPARTMENT, m_pSet->m_Department, m_pSet);
DDX_FieldText(pDX, IDC_VACATIONTIME, m_pSet->m_vacationtime, m_pSet);
//}}AFX_DATA_MAP
There, that was pretty easy, wasnt it? The bold text is what we added to the DDX function; the rest was supplied with the
framework. We can now see the dates field with one slight modification. You will notice, however, that if the day falls in the single
digits it will show a leading zero. I will leave that up to you to change if you like. Now we can concentrate on adding support for
creating a new record. You should see something similar to Figure 8-8 when you run this application. One problem that arises is
you cannot update the date of hire field.
Figure 8: You can create this functional application that will support modifications of records
We will need to create some variables on the stack in order to change the edit box into a CTime object that we may enter into the
database. We will start with a Find function call to look for each month and convert that into an integer. The next step is to find a
blank space and get the next character after it and place it into the day variable. Finally we will read in the year and add that to a
variable as well. We will take these values and place them in a CTime object for use in updating the database. Following is the
code to add to your DoDataExchange function in AppODBC1View.cpp. At the top of the function we will create our variables as
shown here.
int cbMonth, cbDay, cbYear; //variables to store the date
CTime ourTime; //variable to store the CTime object
Now we are ready to use these and make it possible to modify the date of hire field. At the end of this function we will add the
following code.
if (m_date_of_hire.Find("January") != -1)
cbMonth = 1;
if (m_date_of_hire.Find("February") != -1)
cbMonth = 2;
if (m_date_of_hire.Find("March") != -1)
cbMonth = 3;
if (m_date_of_hire.Find("April") != -1)
cbMonth = 4;
if (m_date_of_hire.Find("May") != -1)
cbMonth = 5;
if (m_date_of_hire.Find("June") != -1)
cbMonth = 6;
if (m_date_of_hire.Find("July") != -1)
cbMonth = 7;
if (m_date_of_hire.Find("August") != -1)
cbMonth = 8;
if (m_date_of_hire.Find("September") != -1)
cbMonth = 9;
if (m_date_of_hire.Find("October") != -1)
cbMonth = 10;
if (m_date_of_hire.Find("November") != -1)
cbMonth = 11;
if (m_date_of_hire.Find("December") != -1)
cbMonth = 12;
cbDay = atoi(m_date_of_hire.Mid(m_date_of_hire.Find(" ") + 1,2));
cbYear = atoi(m_date_of_hire.Right(4));
ourTime = CTime(cbYear,cbMonth,cbDay,0,0,0);
m_pSet->m_DateofHire = ourTime;
What we have done here looks like a lot of repetition in the beginning. This is based on a date format being typed as January 9,
1999. We look through the string for a value of each month using the CString::Find function. When found, we set it to the integer
value associated with that month (1 is January, 2 is February, and so on). Notice there is no error checking. For an easier to follow
example, I didnt include which preventative measures you would take to ensure proper data. We will see this at the end of the
section. After we do this, we get the day, which is in the middle of the string. We have to get a little fancy with nested CString
functions. First we call for the CString::Mid function and supply it with a starting point when we find our first space and read the
next two characters for the day. The last field that we need to handle is the year field. With this field, we have an easy call again.
we use the CString::Right to get the rightmost four values in this edit control. One thing these all have in common is the use of the
atoi function. This function converts a string value into an integer. We need integer values from this edit box in order to send them
to the database. We constructed the CTime object and then inserted it into the database. When you compile and run this, you will
be able to move between the records and modify any fields. Be warned though, when using the date of hire field you must stick
closely with the current format when modifying it.
Now we will need to add support for making new records. After all, what good is a database if you can use only a few records to
modify it? In the resourceview bring up the menu. We want to add an entry to the Record menu. Double-click the blank space
underneath it and give it ID_RECORD_ADD for the ID choice. In the caption field type &Add Record. the & preceding the A
will enable keyboard users to choose this option with the keyboard shortcut alt-r, then A. When prompted, insert the following text;
Add a new record to the database.\nAdd Record. this is to add notes for the status bar and tooltips. Now that we can access the
command lets make it do something. Press ctrl-w to get into ClassWizard. the ID we just added should be highlighted. click
COMMAND in the messages list box and click add function. Accept the default and click OK. Choose OK and go to the form
view. Now we will add two buttons, Submit and Cancel, giving them the IDs ID_SUBMIT and ID_CANCEL, respectively. When
creating these buttons select the Disabled box in order to disable them until they are needed.
Double-click each button to add a function for it and select the default name that appears in the dialog box. Press ctrl and
double-click each of them and select control for the variable type. Then, in the member variable name, type an o after each m_. For
example, we have m_Department as a member variable for the CString. we would like a member variable for the control and we
would like to make it look like m_oDepartment. Perform that logic for each of the buttons now. Add control variables for each
button; m_oSubmit and m_oCancel for their respective buttons. Now we will add a toolbar button to emulate adding a new record.
This improves the usability in the interface. Click the toolbar in the resource editor and draw a button. I drew mine to look like an
arrow with a + sign on the end. Name it ID_RECORD_ADD to match the menu choice. Thats it; this button is fully functional
without too much work.
It is time to modify the code for the buttons to add a record. First we will check to make sure the file is not read-only, if it is the
buttons will appear shaded, then we will make each button functional. Here we have the AppODBC1View::OnRecordAdd function
and we need it to enable the buttons and clear the fields. I wont be posting the entire code here, but I will show you some of it to
use as a basis. Here is the code to check the attributes of the file to see if the file was read-only.
if (m_pSet->CanAppend() == 0)
MessageBox("Cannot Add a Record",
"Database Error",MB_OK |MB_ICONERROR);
This is a call to see if we can append a record. if we cannot, we display a message box and inform the user of the error. We proceed
to drop out of the function; if it is okay, then we enter the else statement. This statement contains the code to enable the buttons that
we placed on the form and is shown here.
m_oSubmit.EnableWindow(TRUE);
m_oCancel.EnableWindow(TRUE);
This uses the call CWnd::EnableWindow() to enable the buttons. Here is an example of clearing a field for one of the controls. You
can repeat with all the others as necessary.
m_oemployeeID.SetWindowText("");
That makes use of CWnd::SetWindowText with a blank entry to clear the edit controls, so that the user will get a blank form in
which the new information can be placed. Now we need to do the tedious work of updating the data with the Submit button. In the
OnSubmit function, we will be repeating much of the logic for getting the data into the database that you saw in the DDX function.
We have created temporary variables for use in extracting data from the form. I wont be showing these as they remain pretty
consistent with the style thus far. First, we use the AddNew function to add a new record. Then we retrieve the text from the form
controls, and in the case of a CString data type we immediately enter it into the database. If it is an integer we will have one extra
step. We save the value into a temporary string, and then we call atoi() to change this string into a number. This goes for all the
fields except for the date of hire field. For the date of hire field, you may reuse the exact code that we used earlier to modify this
field as long as your variables on the stack remain the same. We would like to call Update() to update the database and call
MoveLast() in order for the user to see the new record. Finally, we will disable these buttons again because we have added the
entry into the database. In order to make the cancel button work, we hold temporary variables and take the current values from the
database and inject them into the form. You can do this much like you learned how to put data on the form and retrieve data from
the database. You should now compile this project and add a couple of records and modify them to see how close we are.
The last thing you will want to add to a standard database file is a search function. We will create a toolbar button and menu choice
to search for a value in the database. In this function we will create a number of variables on the stack for temporary checking. First
we will want to check if we can get a bookmark from the database to store temporarily in case the search doesnt find a record. The
functions to see if a bookmark is available and to get it are: CanBookmark, which takes no parameters, and GetBookmark, which
takes a CDBVariant to hold the bookmark. You will also want to create a dialog box to attain a value to search for. Then you will
traverse the database searching for the string. if the string is found, you will copy the data members into the edit controls. if it is not
found, restore the bookmark or move somewhere else if it doesnt support bookmarks.
This wraps up the discussion of ODBC techniques. The main use for this is compatibility with a wide variety of DBMS. The
drawbacks remain to be its slow speed and the fact that Microsoft encourages developers to use ADO or OLE DB for their database
needs. Another database technology that is becoming less commonly seen is DAO.
DAO
DAO is a good choice for a fast operation on a local database. It is not as widely supported as ODBC is and cant be used for
remote data access. This is the choice for small businesses with the needs of a simple, quick, database application. We will look in
detail at the MFC classes that support DAO and some code snippets. We wont be building a database application here because it
isnt very far from dealing with an ODBC database and the class overview should give you enough information to make one.
Remember, when using DAO you will need to #include <afxdao.h> in your project.
DAO has strong support for Jet databases; this is the engine that ships with Microsoft Access. MFC wraps the DAO objects in a
smaller selection, but contains all of the functionality of DAO. DAO contains seven classes; we will begin with the class that you
will interact with the most. The list of classes is CDaoRecordset, CDaoDatabase, CDaoWorkspace, CDaoFieldExchange,
CDaoTableDef, CDaoQueryDef, and CDaoException.
CDaoRecordset parallels the ODBC class CRecordset. They both represent the data and allow changes on that data.
CDaoRecordset creates the recordset for your use. The recordset will support three different choices to display the data. Table,
dynaset, and snapshot are all supported with DAO; you will remember that table is not a supported method for ODBC-based
applications. A table is a method of using a base table as your recordset. You may perform all of the actions you are accustomed to
when dealing with databases. These include viewing, adding, modifying, and removing records from the table. We covered dynaset
and snapshot earlier so I will give a short description of each of these. A dynaset is a dynamic recordset that reflects changes as the
user makes them. A snapshot is a static recordset that will keep the same copy of the data as when the query was executed until
Requery() is called. CDaoRecordset enables you to scroll through the records and set an index for quick access to particular records
using CDaoRecordset::Seek. This only works when you use a table recordset. You may lock the records when using a dynaset or a
table-based application. You may sort the recordset or parameterize the queries, enabling the record to be sorted at run time.
CDaoDatabase handles the connection to the database that enables you to modify the data. CDaoDatabase works closely with
CDaoWorkspace when you would like multiple connections open at the same time. We will take a look at that aspect in a moment.
CDaoDatabase is the DAO parallel for the ODBC CDatabase object. You may use this to create an object in a new database by
choosing the CDaoDatabase::Create function; you do not need to call open when you are creating a new database. On the other
hand, you can open an existing database by creating the object and call the CDaoDatabase::Open function. This method will tie in
with the CDaoWorkspace class and you may work with it on a transaction level, which we will cover transactions in the next
section.
CDaoWorkspace is what manages the database(s) from start to finish. You can have multiple database objects in a workspace to
manage the different connections. If you happen to be using a single connection, you will be satisfied with MFCs default
workspace. You may use this to deal with transactions that are groups of updates to databases. You will first need to call
CDaoWorkspace::BeginTrans in order to start the transaction process. Once you are in a transaction setting, records are no longer
updated as you go. Once you are in this mode you have two choices for getting out: CommitTrans and Rollback. CommitTrans will
perform all the modifications on the data, whereas Rollback will cancel the changes. If you happen to close the database while in
transaction mode, the changes will be rolled back.
CDaoFieldExchange (DFX) is DAOs equivalent of the ODBC DDX functions. There is no need to involve yourself with this
function unless, as we did earlier, you have data types that arent supported. DFX supports bi-directional data updating, swapping
to and from the data source. Like DDX, we will be using SetFieldType often in order to specify what kind of data the member
variable will be receiving. If you are comfortable with DDX you will feel right at home with these functions.
CDaoTableDef holds a list of all the tables in the database in a collection. These collections are stored in TableDefs. The reason for
this class is to allow you access to these TableDefs and to create them. With access to these TableDefs you may modify them or
just extract information from them. Calling CanUpdate will enable you to see if you have access to modify the field definitions in
the table. When using a saved table, you would call the Open function. When making a new table you call the Create member
function and CreateField and CreateIndex will create fields and indexes to the table. Calling Append will save the table. You might
want to consider handling this all in Access because then you only need to open them in your code.
CDaoQueryDef is an object that accesses a query that is most likely saved in a database. It also has the power to create a query.
This class can handle raw Structured Query Language (SQL) queries for data sources that are not Jet based. Like what we have
seen with the other classes, an Open function opens a query saved with the database, whereas a Create function makes a new one,
and Append adds it to the QueryDef object. to create temporary QueryDefs, you call create, pass an empty string for its name, and
dont call append. Like the others, the most convenient way to use queries is to create them in Access and just call open from your
project.
CDaoException is the last DAO function provided for us in MFC that we havent covered. We use this to handle exceptions
generated by the MFC classes supporting DAO. CDaoException has functions to attain the information within the exception
thrown. When you catch the exception, you can generate one in your code with AfxThrowDaoException. there are the member
functions GetErrorInfo to retrieve information about a particular error object in the database, and GetErrorCount to get the number
of errors in the collection. There are a few more error checking procedures for this class. These include member variables that store
basic and extensive information about the current error.
MFC does well with wrapping the DAO software developers kit (SDK) and provides a very easy-to-use framework when you
create a DAO application in the AppWizard. For practice, I would recommend creating a DAO version to work with the database
we created earlier. The DAO method is speedier than ODBC for access to locally-supported database types. However, DAO isnt
able to access remote databases, such as Microsofts SQL server, with as much speed as ODBC. DAO wraps ODBC to access data
sources such as those, but then you have an extra level of commands to get to the data.
Exam Watch: DAO is typically associated with Microsoft Access .mdb files which use the Microsoft Jet database engine.
OLE DB
OLE DB is the next step in speed and support for a large number of data sources. As we slowly progress into standardization for
this technology, OLE DB has the capability to wrap the ODBC for backwards compatibility. Two key points of OLE DB that make
it attractive are that OLE DB can use a generic interface to writing components through the use of COM, and OLE DB isnt reliant
on a form of SQL to access data sources like ODBC is. As you have seen with COM, you have a new way to create modules and
update modules that will remain backward compatible. This will help us greatly in a data access environment, because many times
several different types of machines will need to access the same data depending on how the network is set up. Speaking of
networked environments, another form of COM will handle this gracefully. Now we have DCOM available to us for use in a
distributed environment. You will see this when you take the next test for distributed applications. Let us get back to COMs role in
OLE DB.
OLE DB makes use of consumers, providers, and services. A consumer is, as you may be able to guess, an application that makes
use of data given by the provider. When your application attains access to a data source through OLE DB, it is classified as the
consumer. When you grab a template from the Active Template Library (ATL) and it supports OLE DB access to a data source,
this is another example of an OLE DB consumer. As you have guessed, there are many different OLE DB consumers.
An OLE DB provider is like a driver for ODBC in that it grants access to the data source for the consumer to use. There is a
minimal amount of functionality that a provider must implement. This includes allowing a connection, retrieval of information, and
stepping through the data. This is just the minimum functionality that it needs to provide, but it can be expanded to provide
in-depth functionality. Some OLE DB providers support the two technologies we had mentioned earlier as well as other
technologies.
In Visual C++ we have providers to access data from the following common data sources: ODBC drivers, Jet databases, SQL
Server, and Oracle. The ODBC provider can replace a straight ODBC connection to data sources needing an ODBC connection;
and there still are many. The OLE DB provider for Jet databases can replace DAO and has support for Access files and FoxPro
files. The OLE DB provider for Oracle supports Oracle 7.3.3 to the current version.
OLE DB services are also known as service components. These components provide and use data. A query processor will get
rowsets and return them to a client. A cursor engine will step through some data and can select a rowset. A synchronization
component will synchronize and update a rowset that has undergone changes by either you or another user. A shape component
deals with hierarchical data and allows you to create rowsets based on this.
To access data with OLE DB, you need to initialize COM with a call to CoInitialize. Then, calling CoCreateInstance creates the
object. Following this, you should set properties for the provider and open the data source. Create a rowset and open it. Create an
accessor to retrieve information from the rowset and bind it to the accessor. An accessor makes OLE DB unique by storing the
bindings of a rowset with the details of how data is stored. Now is when you can use the data for your needs and then release the
objects. Uninitialize COM when you are through with the objects. You may find that certain interfaces are mandatory, but when
you add certain interfaces, other interfaces become mandatory. Say you choose to use the optional command object, then you are
required to use six specific interfaces.
An advantage of using OLE DB is its basis on COM. This enables a great compatibility with web-based applications. It can reduce
traffic over the network by only making a connection when a data modification or data needs to be retrieved. A problem with OLE
DB is that it is inaccessible directly with the higher-level languages. Another problem is when you use the providers to access
technologies through ODBC, it adds another step between your calls and the data source.
ADO
OLE DB isnt available to a higher-level class of languages, so this is where ADO steps in. Even in OLE DB, dealing with the
COM objects can get complicated. ADO is around to simplify things a bit. ADO provides an easier means to take advantage of the
power of OLE DB. The web is providing a familiar interface for database access and manipulation. The key to this is a new
language developed by Microsoft called Active Server Pages (ASP). ASP does not directly use the ADO objects, as you may be
used to, it just calls these objects that were previously compiled.
ADO is predominantly used by Visual Basic (VB) programmers, so they can have the power of OLE DB to access data. Because
this is used in a predominantly VB setting, the documentation in the MSDN help for using it with VC++ can be a daunting task to
locate.
There are seven objects that make up the ADO object model. These objects help to make ADO much more efficient than DAO.
Here is a list of these objects:
connection objectis the session between a data source and your application. There are a number of options you can set
before connecting to the data source. When this connection is made, you can use simple queries. This is also the place in which you
would have support for transactions, including BeginTrans and either Rollback or CommitTrans.
error objectIs similar to the error objects we talked about earlier. They do not cover errors on the ADO level; however, they
do show the errors from the OLE DB level.
command objectis a query or stored procedure and the parameters necessary to be able to run this object. The command
object is also optional, because only some providers support it. If we have a SQL data source, the command object is the
representation for the SQL statements that will perform queries on the data source. This object can store many different command
types such as tables and stored procedures. It can hold a collection of queries that can be run more than once without the need of
re-specifying your query every time it is used.
parameter objectis closely related to the command object. A parameter is used for dynamic queries based on user input to
execute a command. A parameter object has many properties associated with it, including name, data type, value, and direction for
the parameter. OLE DB may automatically create these when you refresh the parameter collection. For speedier access you may
create these objects yourself.
recordset objectis a wrapper around the OLE DB rowset object. The recordset is a complex object that represents the data
attained from the data source. It keeps a position reference to the current record. Using this object you can step through the data a
record one record at a time or jump to the first or last records. This even has the power to retrieve data sets when you do not use a
command object. Another supported feature is batch updating which, like transactions, can update all data in a chunk, reducing
connections to the data source.
field objectrepresents the information about the columns attained from the data source. The information contained in this
object is the name, size, type, and, when necessary, data precision.
properties objectkeeps information for the capabilities of the data source. Contained in the property object are these four
properties: attributes, name, type, and value. The properties of a property object can be changed.
we can access ADO by using MFC OLE, the SDK for OLE, or #import. In order to use ADO you need to become familiar with a
couple of the data types that it makes use of. BSTR and VARIANT are the two types. perhaps if you come from a language like
Visual Basic you are familiar with these, but I will explain how to make use of them in VC++. A BSTR isnt able to be assigned
directly to an array of characters, so you have two options; you can either convert a string into a BSTR with some creative coding,
or you can use the CString::AllocSysString() function which will return a BSTR for you. A BSTR is a pointer to a wide character
array. There are functions in MFC OLE that allow you to perform a couple of functions on the BSTR data type. They provide you
with functions to compare, get a length of, copy, and allocate BSTR. The other type is a VARIANT. A COleVariant is the way we
can represent a VARIANT in MFC. A variant is a structure that contains many different data types.
We will use MFC OLE to access ADO from within VC++. To wrap it in VC++ you will need to add a class from a type library. To
do this choose Insert | New ATL Object. The file you want to include here, from the dialog that pops up, is called Msado15.dll. In
the next step you should select all of the classes. MFC AppWizard will automatically add two files called Msado15.h and
Msado15.cpp. These files have the wrapper of ADO that we can use. The functions in the implementation file, as you may expect,
call helpers from the .dll file. These functions dont return anything, which makes error detection difficult. Enumerated types used
by this library arent automatically included when you insert it, so you will need to add them manually.
By using #import to import the .dll file, you gain access to the wrapper classes. Be sure to add no_namespace after the path and
file declaration. This holds primary headers and will avoid collisions of names in the program. Using this method to use ADO in a
VC++ application will hide VARIANT and BSTR from you. Instead you will use the keywords _variant_t and _bstr_t. This
method allows you to handle exceptions returned with HRESULT. This is the most common and simplistic way to use ADO With
VC++.
Using the OLE SDK is quite common as well and gives you direct access to your error handling. You can use this in MFC, so
generating a user interface will still be familiar to you. Like the other ways to create a database application, the OLE SDK will
have pointers to ADORecordset and ADOField; these are pointers to a recordset object and a to a field. You have to create the
member functions to open, get data, and store data. You will create a COM object and put a formatted connection string the
ADORecordset::Open command. When placing or retrieving data, you make extensive use of COleVariant to move data back and
forth. ADO 2.0 solves the problem of the use of VARIANT; you may simply bind the variables directly to the data source columns.
Exam Watch: ActiveX is Microsofts successor to OLE. They allow objects to be embedded within another program. For example,
the Internet Explorer web browser is embedded into your Visual C++ integrated development environment (IDE).
RDO
With the web age here and stronger than ever, remote data access must be one tool you can use. RDO is like DAO, but it has direct
access to ODBC drivers. These objects retrieve a recordset, manipulate it locally, and then send the modified record back to the
server to update its data source. To reduce network traffic, we would want this to support transactions. This would queue the
changes and then connect to the database and deliver all the changes at one time. Another way to limit traffic would be to specify a
limit on the number of rows that will be returned. Using RDO gives you ten objects at your disposal. I will cover them each briefly.
rdoEngine is always created when you use RDO. rdoError is the error-handling object. The RDO object that manages connections
and transactions is rdoEnvironment. A connection to the remote server is handled with rdoConnection. For queries we would use
rdoQuery. Column information is contained within rdoColumn. A parameter that may be input, output, or both, and can be
associated with a query is rdoParameter. The rdoResultSet is like a recordset that returns the rows obtained from a query. A table is
represented by rdoTable. A saved query definition is rdoPreparedStatement; this is actually outdated and rdoQuery takes over its
functionality. Three of these are created automatically when you initialize RDO and you create the other six. The three that VC++
creates are rdoEngine, rdoEnvironment, and rdoError.
To use RDO in VC++, you follow a similar process as using ADO in VC++, except you make your DAO objects call with RDO
functions. This is our workaround because RDO was mainly intended for VB. Alternatively, in ClassWizard you can import a class
from a type library; the library we are looking for is msrdo20.dll. The wrapper class will be created for your use. We can work with
this wrapper to perform all of our database needs.
On the Job: RDO and ADO are mostly used by Visual Basic and ASP developers to interface remote database sources. In Visual
C++ we deal mostly with OLE DB. Up until very recently RDO was not supported at all for a VC++ programmer, and the
documentation is severely lacking for a VC++ developer who would like to use ADO.
Data-Source Control
In Visual C++ you have access to many data-source controls. We will cover one here for use in a ADO application. Build an
application as you normally would. In step 2, choose database view without file support. Next, click the Data Source button. In the
dialog box that appears, choose OLE DB and select OLE DB Data source. From the providers tab choose the Jet OLE DB provider,
because we are using the access database that we created earlier. Choose next and select the database file from the earlier ODBC
example. You may leave the username and password fields alone as we didnt specify them when the database was created. Here is
where you should test the connection to make sure it is accessible. Click the button and you should see that it succeeded. Click OK
twice and choose our query, LongForm. although choosing a query isnt always necessary, it is generally practiced because it has
the data you want sorted the way you want it. Now you can click finish. Click the ok button in the project. Now we have our
project and a blank form available. I will go step by step on how to use a data-source control in your project.
Select Project | Add to Project | Components and Controls. Choose the Registered ActiveX controls folder. Browse to the
Microsoft ADO Data Control. Select this and click Insert.
1.
Click OK on the confirm classes dialog box. This will add a button to your controls toolbar. 2.
Add another control in the same manner for Microsoft DataGrid control. This control will be used to display the data. 3.
Add these controls to the toolbar in any manner you like. 4.
Here we will configure the controls that we added. Right-click the data list control and choose properties. On the all tab click the
DataSource field and choose IDC_ADODC1 from the combo box. Right-click the ADO control and choose properties. We need to
select the data source for this control. You can do this by clicking the control tab on the dialog box and building the connection
string. Choose the Microsoft Jet Provider and click next. Again, select the database we used earlier. Test the connection and you
will see the success. Now click OK. Go back to the properties for this ADODC control. If you have basic knowledge of SQL you
will recognize the next thing that we do. Go to the RecordSource tab and enter the following for the Command Text edit box:
Select * from LongForm
Close this dialog box. We are now ready to compile it. Upon executing this, you will see the data displayed in the grid. I must
mention a caveat here. To scroll through the text you need to use the ADO control, this is because now you have dual connections
to the data source. you can connect these together with some code. Additionally, we dont have support to add or delete records.
This can be changed in the properties of the datagrid control. Changing the size of the window wont be reflected with the datagrid,
so if you like, you can override the OnSize function.
This gives you a good start with an ADO application as well as using data-source controls to ease your way into these newer data
access methods. These controls, as you can now see, do quite a bit of work for you. We didnt need to bind member variables to the
fields for swapping as this is all done transparently to us. We will explore database errors next.
Handling Database Errors
A common element to most database access methods is some type of error detection. We can handle database errors gracefully if
we learn what is available to find these errors. In most cases we will have an exception thrown that contains more information
about the error. For example, if you forget to check for the end of the file and step through the records until the end, a
CDBException will be thrown. You can test for this with a routine similar to the following code snippet.
try
{
m_pSet->MoveNext();
}
catch(CDBException* exc)
{
AfxMessageBox(exc->m_strError);
exc->Delete(); //remove exception object
m_pSet->MoveLast(); //move to the last record we probably over stepped it
UpdateData(FALSE);
return;
}
This tries a MoveNext() to step to the next record. If an exception is thrown it will be caught and the error message is displayed.
We will move to the last record, because more than likely we had stepped over it. There are many other errors that may be loaded
into the exception object for you to catch. There are also times that you would like to throw an exception yourself and with MFC
you may use the AfxThrowDBException() function. Typical error messages that you will see are SQL_ERROR*. The exceptions
thrown by the framework are AFX_SQL_ERROR*.
Other database access methods will throw similar exceptions. For instance, DAO code might look similar, but the exception object
is CDaoException. This time, rather than the member function containing the actual text of the error message, it contains a pointer
to a CDaoErrorInfo object. This object contains the actual information of the error. If you are using DAO directly you will need to
call GetErrorInfo, which is a member function of the exception object, in order to fill in the m_pErrorInfo pointer.
With ADO and OLE DB you dont get an exception object or a pointer to an exception object. Instead, you may use an optional
error object. If you choose against this, each object does report its status and diagnosis in an HRESULT. For further detection and
reporting you would probably want to use the error object provided. They may give a SQL error message, a description of the error,
or further information on any error throughout your data access procedures. In ADO, the OLE DB provider supplies the error
objects. With ADO you get an error closer to your application code. You may handle these errors in your code and provide a
graceful recovery. RDO errors are generally the same as OLE DB errors. You have an error object with error information. Then,
within your code you decide how to recover from it and let the user know what has occurred. Lets see how to work with an error
object in ADO.
try
{
RecordsetPtr pRset.CreateInstance(_uuidof(Recordset));
}
catch(_com_error &e)
{
CString szErrorOutput;
szErrorOutput = e.ErrorMessage();
MessageBox(szErrorOutput,Error!,MB_OK);
}
Here we have tried to create a Recordset instance. If there is an error, then we catch the error object and display output for the user.
Normally, you would want to provide code to recover gracefully from the error in addition to informing the user.
Handling errors is imperative in your code in order to provide a secure application that wont corrupt your data. Errors can also
crash your program as well as others that are running if they arent dealt with properly. Using exceptions and error objects isnt a
complete solution. They must be used in an appropriate manner and place the user in a useful situation. If this is not possible, a
graceful recovery is quite necessary so that data is not corrupted and does not cause other programs to crash.
From the Classroom
An ADO mini-primer
In this section we discussed various data access techniques, including ADO. ADO is part of Microsofts Universal Data Access
(UDA). As UDA becomes more popular, C++ programmers everywhere are going to be delving into the ADO object model. When
providing data services for your application, it is important to deal with any errors that arise when making calls to your database.
So, lets take a look specifically at how you can catch database errors if you are using ADO to perform data access in your
application.
As described in this section, to use ADO in your application you will need to import the MSADO15.dll into your stdafx.h file using
the following command:
#import <MSADO15.dll> no_namespace rename ( "EOF", "adoEOF" )
The no_namespace option, as mentioned earlier in this section, avoids name collisions in your program, and the renaming of EOF
is necessary to avoid a conflict with named constants. Importing this .DLL adds all of the objects needed to use ADO. The three
objects that we are going to look at are the Connection object, the Errors collection, and the Error object.
Errors, using ADO, are associated with the database connection object. I can declare a smart pointer to a connection object using
the following code:
_ConnectionPtr pCon(__uuidof(Connection));
Then I can perform some operation on my connection object, such as the following open operation:
pCon->Open( myDSN, myDBUser, myDBPassword, -1);
I could then check to see if the open operation was successful by checking its state with the following:
If (pCon->GetState() == adStateClosed)
//Check to see what went wrong
To see what went wrong, I can get the Errors collection from the connection object using the following:
ErrorsPtr pErrors = pCon->Errors;
I can obtain the first error in the Errors collection with the following three lines of code. (The first error is usually the one you will
be interested in, however, if there is more than one error in the Errors collection you may wish to loop through the Errors collection
and extract information from each error.)
short index = 0;
_variant_t vtIndex = _variant_t(index, VT_I2);
ErrorPtr pError = pErrors->Item[vtIndex];
After I have a pointer to the Error object, I can extract details about the error that occurred, including the Description, Number,
Source, HelpFile, HelpContext, SQLState, and NativeError. For example, to get the description I would simply add the following:
_bstr_t sqlState = pError->Description;
You might have noticed the use of the _bstr_t and the _variant_t data types. It is necessary to use these COM wrappers for the
VARIANT and BSTR data types when dealing with the ADO objects. Because ADO uses COM, the Cstring class is not used by
the ADO classes.
This quick introduction on how to handle errors using ADO should help you get started with using ADO in your applications. As
the author of this section mentioned, the use of ADO in C++ applications is not currently well documented. so, after you have
exhausted the Microsoft Developer Network (MSDN) and other C++ web sites, you can view all of the ADO classes and their
methods and properties by opening the MSADO15.tlh file located in your project build directory. I will give you fair warning that
this file is not organized as an easy-to-use reference, but with some good hunting techniques and a little trial and error coding, you
can jump on the Universal Data Access bandwagon and make use of ADO.
Michael Lane Thomas, MCSE+I, MCSD, MCT, MCP+SB, MCDBA, MSS, A+
In this chapter we have discussed how to interface your program with data. We have looked at different data sources from a
standard text file to a complex database. We displayed data from a data source and serialized it. We stored our data to files and read
from the files using CFile and CArchive classes that MFC provides in the libraries. We learned various methods to use to interface
with a database file, including older technologies such as DAO and ODBC as well as newer methods like OLE DB, ADO, and
RDO.
Using CArchive to access data files on persistent storage is very practical if your classes are derived from CObjects. This enables
MFC to hide the CFile object from you and handle the storage behind the scenes while you simply send or receive a stream. This is
a good place to recap what the CFile class can do for you. CFile will actually store your data to a persistent storage. The classes do
not need to be derived from CObject and can be stored in memory as well as on disk. Other classes based on CFile allow you to
just work with a plain text file or memory file. When using CArchive, the framework contains the creation and deletion of the
CFile object for use in persisting the stream. CArchive is also a great tool for streaming data out over a socket; such as what is done
when you send or receive data from the internet.
In preparation for accessing databases, we created a simple one in access. Then we connected the recordsets, or fields, to dialog
box controls in order to display the data. We do this with a method called record field exchange (RFX). We normally dont need to
make too many modifications in the function they provide for RFX, which is DoFieldExchange(). In order to pass data to these
controls and retrieve data from them, MFC has provided us with dialog data exchange (DDX). Typically, unless you are using very
simple fields, this function will need to be modified for accuracy in displaying data and collecting data.
ODBC has wide use because most database management systems (DBMS) ship with a driver supporting ODBC connections. The
problems we noted were as follows: ODBC is slow, ODBC requires the data source to fit the SQL query format, and ODBC
doesnt support remote data sources. we saw that DAO has the easiest way to access a local data source based on Microsofts Jet
database engine. The problems we encountered here were the lack of support for remote data sources and the limited compatibility
with various DBMS. ADO was shown to be a little difficult to work with in VC++, because its main intent was for use in
higher-level languages such as Visual Basic and Active Server Pages. This is like a wrapper around OLE DB, because those
higher-level languages need a way to access the power of it. The power is that OLE DB is able to access data sources and be
backwards compatible by using providers for the older methods. OLE DB has two key strengths. First, and its most powerful
feature, is that it is based on COM, enabling components to be developed in a variety of languages and then be seamlessly
integrated into a program. The other strength is that it can be used to access a wide variety of data sources. There is no need to
convert them so they can be accessed with SQL commands. RDO is a newer technology that allows you to basically add remote
access to DAO. The weakness is the code becomes more complex if you dont have a good understanding of COM. You can use
RDO commands in your DAO function calls to obtain access to remote data sources. MFC has data-source control providers
available for your use. These can be added to your control toolbar and in some cases will speed up your application development.
We saw an example that immediately displayed and traversed through data without dealing with the RFX or DDX. However, this
does add complexity to modifying the code as you will need knowledge of COM.
Lastly, we covered how to handle database errors for the various data access methods. Some involve having an exception object,
whereas the others have error objects. When you have the exception objects, it is a wise choice to catch them and recover from the
error and then inform the user. The error objects are not mandatory because error messages get sent with the other objects, but
using error objects will keep your application user-friendly by providing more detailed messages to them and providing smarter
error handling code to your application.
Two-Minute Drill
CArchive is a great class to use in a document/view application for file I/O because it makes use of the Serialize virtual
function.
CFile is a direct method of file input/output (I/O). CArchive is a great class to use in a document/view application for file I/O
because it makes use of the Serialize virtual function.
CFile class will let you directly access file I/O on the disk for persistent storage. This is the base class in MFC for many
useful file operation classes including CStdioFile, for plain text management, and CMemFile, used for temporary storage for fast
transfer of raw data.
CArchive is used mainly for saving objects to a binary form that will remain accessible even when those objects are deleted
in the program.
In the document/view architecture, MFC supplies you with the convenient CArchive and CFile classes with the framework.
MFC connects your recordset to dialog box controls with record field exchange (RFX) and with dialog data exchange (DDX)
in a two-step process.
OLE DB uses Component Object Model (COM) to interface the databases.
DAO is a good choice for a fast operation on a local database. It is not as widely supported as ODBC is and cant be used for
remote data access.
OLE DB has the capability to wrap the ODBC for backwards compatibility.

Chapter 9: Testing and Debugging the Solution
Using Library Debugging Support 2
Using the IDE. 7
Using Depends. 16
Using Spy++. 19
Integrated Debugger 25
MFC Macros Used to Debug Applications. 34
Beta Testing. 39
Regression Testing. 40
Unit Testing. 41
Integration Testing. 41
Stress Testing. 42
Two-Minute Drill 46
Debugging Techniques
Elements of a Test Plan
Testing and debugging are very important areas in application development. You want to make sure your application works properly for your
customers. This is also an important area for the exam. There are commonly quite a few questions covering this area and it is critical to
passing the exam. We will cover testing and debugging an application and the tools included with Visual C++ to help this process. For
debugging applications, Visual C++ comes with run-time library support, tools built into the integrated development environment (IDE), the
Depends tool, the Spy++ tool, and Microsoft Foundation Class Library (MFC) macros. For testing applications, we will cover the elements of
a test plan including Beta, unit, integration, and stress testing.
Debugging Techniques
Debugging an application allows you to find errors in your application. Errors can be programmatic or logical. There are many techniques and
tools available for debugging applications. In this chapter, we will only cover the areas relevant to the Microsoft Certification Exam. We will
cover the tools available in Visual C++ and when to use each of the tools.
Using Library Debugging Support
When you create a project, both a debug version and a release version are created. For the debug versions, some extra files are created to hold
debugging information. Two .PDB (Program Database) files are created. It will create a VCx0.PDB file where x is the version number of
Visual C++ (for example, VC60.PDB). This file contains debug information about types for the object files and is placed in the same directory
as the makefile. This file is created when you compile an .OBJ file. In addition, a project.pdb file is created where project is the name of the
project. It contains all debugging information for the .exe file. This file is placed in the \Debug directory. This file is created by the linker. The
project.pdb file is used by the Visual C++ debugger.
Visual C++ includes debugging support in the run-time library. This allows you to step into a run-time functions code and contains functions
to help locate memory leaks and other memory problems, and to view the heap. When you build a debug version of your application, the
run-time debug libraries are linked by default.
There are three common debug libraries. The library that is linked depends on the project you are building. The LIBCD.LIB library is used for
single-threaded, static link projects, the LIBCMTD.LIB library is used for multithreaded, static link projects, and the MSVCRTD.LIB library
is used for multithreaded, dynamic link projects.
The debug libraries include debug versions of malloc, free, calloc, realloc, new, and delete. These can be used for finding memory leaks. A
memory leak can be caused by not freeing memory when it is no longer needed or goes out of scope or by changing a pointer without freeing
the memory it was pointing to. This memory cannot be used again. You could eventually run out of memory if this occurs enough times.
These problems can be difficult to isolate because the results can be intermittent and not apparent until a different part of the code is executed.
Also, small leaks might not have any visible side effects until the application has been running for a long time. The following code
demonstrates some examples of memory leaks:
//memory is allocated, but not freed when the procedure loses scope
void OutOfScope()
{
int *ptr;
ptr = new int;
*ptr = 1;
}
//a pointer is changed without freeing the memory it was pointing to
void ChangePointer()
{
int *ptr1;
int *ptr2;
ptr1 = new int;
ptr2 = new int;
*ptr1 = 2;
ptr2 = ptr1;
free(ptr2);
}
Another common memory problem is writing past the allocated memory. An example would be creating an array and writing to an index
beyond the size of the array. Another example would be writing to a pointer that hasnt been allocated. See the following code for examples.
//writing past the allocated memory
void WriteTooFar()
{
int i;
int ptr[3];
//when the below for loop reaches 3, it is writing to memory that is not
//allocated to the array
for (i = 0; i < 5; i++)
ptr[i] = i;
}
// would be writing to a pointer that hasnt been allocated
//when you compile this code, you will receive the following warning:
// warning C4700: local variable 'str2' used without having been initialized
void WriteToUnallocated()
{
char str1[20];
char *str2;
strcpy(str1, "Copy a string.");
strcpy(str2, str1);
}
In a debug build of a project, the debug versions of the preceding memory heap functions are called by the function. For example, when
malloc is called, it would in turn call the malloc_dbg function. Extra memory is allocated for debug information. Part of the extra memory
allocation is to put known values in memory before and after the allocated memory. This is checked to see if the memory is being written to in
error. This gives you a debug heap that can be checked for integrity. You must make calls to check the integrity of the heap. As an example,
call the CrtCheckMemory function to inspect all memory blocks in the heap, verify that the debug information is valid, and confirm that the
buffers around the memory allocated have not been written over. You can also control how the debug heap keeps track of allocations using the
CrtSetDbgFlag function. You can instruct the debug heap to check for memory leaks when the program exits, and report any leaks that are
detected. Table 9-1 displays a listing of other debugging functions.
Function Description
_CrtDumpMemoryLeaks
Used to dump all of the memory blocks on the debug heap when
a memory leak occurs
_CrtIsValidHeapPointer Used to verify that a pointer is in the local heap
_CrtIsMemoryBlock Used to verify that a memory block is in the local heap
_CrtIsValidPointer Used to verify that a specified memory range is valid
_CrtMemCheckpoint
Used to obtain the state of the debug heap and place it in a
_CrtMemState structure
_CrtMemDifference Used to compare two memory states for significant differences
_CrtMemDumpAllObjectsSince
Used to dump information about objects on the heap since a
specified checkpoint or start of program execution
_CrtMemDumpStatistics
Used to dump the debug header information for a specified
memory state in a user-readable form
_CrtSetAllocHook
Used to install an allocation function you created by hooking it
into the C run-time debug memory allocation process
_CrtSetBreakAlloc Used to set a breakpoint on an object allocation
_CrtSetDumpClient
Used to install a function you created that is called every time a
dump function is called for _CLIENT_BLOCK type memory
blocks
_CrtSetReportFile
Used to set the file that is to be used as a destination for a report
made by _CrtDbgReport
_CrtSetReportHook
Used to install a reporting function you created by hooking it
into the C run-time debug reporting process
_CrtSetReportMode
Used to set the general destination for a report made by
_CrtDbgReport
_RPT[0,1,2,3,4,]
Used to track the applications progress by generating a debug
report with a formatted string. It doesnt provide source file and
line number information.
_RPTF[0,1,2,3,4]
Same as the _RPTn macros, but adds the source file name and
line number where the report request was made
Table 1: Descriptions of Some Debugging Functions
To set the project build version, you need to set the active project configuration. To accomplish this, from the Build menu, select Set active
configuration. This will bring up the Set active project configuration window. From here, you can choose between the Debug and Release
versions of your application. This will determine which version is built or run from the Project Workspace. The Set Active Project
Configuration window is shown in Figure 9.1.
Figure 1: Use the Set Active Project Configuration window to choose between the release version and the debug version of your application
Using the IDE
The IDE has many debugging features available. Many of the features can be accessed from the Debug, Build, View, and Edit menus. The
most common of these debugging commands can also be accessed by the Debug toolbar. Table 9-2 describes the debugging commands most
likely to be seen on the exam.
Command Function
Restart Restarts the execution of the program from the
beginning. It reloads the program into memory, and
resets all variables.
Stop Debugging Stops the execution of the program that is currently
being debugged
Break Execution Suspends the execution of the program from where it is
currently executing. Can be thought of as a pause button
Apply Code Changes This applies the changes to code for use with the new
Edit and Continue feature
Step Into Single steps through lines of code. When it reaches a
function call, it steps into the function allowing you to
step through the lines of code inside the function call.
Step Over Single steps through lines of code. When it reaches a
function call, it steps over the function so you do not
have to step through the function code.
Step Out Exits the current function to the line of code
immediately after the call to the function
Run To Cursor Executes the program until it reaches the line of code
that the cursor is currently on
Quick Watch Displays the Quick watch window
Watch Displays the Watch window
Variables Displays the Variables window
Registers Displays the Registers window
Memory Displays the Memory window
Call Stack Displays the Call Stack dialog box
Disassembly Displays the Disassembly window
Table 2: Debugging Commands
Debug Toolbar
Some of the debugging commands can also be accessed by the Debug toolbar. The toolbar contains the most commonly used debugging
commands. The Debug toolbar is shown in Figure 9-2. This toolbar contains buttons for the following commands in the order on the toolbar
from left to right: Restart, Stop Debugging, Break Execution, Apply Code changes, Show Next Statement (shows the next statement to be
executed in your code), Step Into, Step Over, Step Out, Run To Cursor, Quick Watch, Watch, Variables, Registers, Memory, Call Stack, and
Disassembly.
Figure 2: The Debug toolbar contains commonly used debugging commands
Even though the debug commands can be executed from the Debug menu or the Debug toolbar, most of them can also be accomplished from
function keys on the keyboard. Many programmers, myself included, like to do as much as possible from the keyboard. It slows you down to
have to reach over and use the mouse. The function keys that can be used instead of the menu and toolbar can be seen in Figure 9-3. Some
additional commands available are:
Step Into Specific Function Steps through the code in the program, and step into the
specified function call.
Exceptions Displays the Exceptions dialog box. This can be used to
specify how you want the debugger to handle your
program exceptions.
Threads Displays the Threads dialog box. This can be used to
control program threads.
Figure 3: You can use the function keys shown on the Debug menu to execute the debug commands
Build Menu
On the Build menu, there is a Start Debug item that contains a submenu. It includes commands to start debugging a project. The command
available on this menu that we have not covered yet is Attach to Process. This command can be used to attach the debugger to a process that is
running on the system. This way, you can break into a process and perform debugging operations on it. The process does not have to be
started from within Visual C++. This can be useful if you have a module you are working on that is part of an application for which you do
not have all of the source code. In this scenario, you cannot start the application from within Visual C++, but you can attach to the process and
perform debugging on the modules for which you have the source files. The Build menu is shown in Figure 9-4.
Figure 4: You can access the Start Debug command from the Build menu
View Menu
On the View menu, you can open up the debug windows. This menu is shown in Figure 9-5. You can open the following debug windows:
Watch, Call Stack, Memory, Variables, Registers, and Disassembly. These can also be opened using the Alt and number key combinations
shown in the figure.
Figure 5: The Debugging commands on the View menu help you to debug your applications efficiently
Watch Window
The Watch window is probably one of the most commonly used debug windows. You can use it to specify local and global variables and
expressions that you want to watch while running your program. You can modify a local variables value from this window. The Watch
window is shown in Figure 9-6.
Figure 6:The Watch window allows you to watch specific variables and expressions while running your program
There are four tabs at the bottom of the window. This allows you to maintain separate sets of watch variables without having to wade through
variables that are not in the current scope. If you have an array, an object, or a structure variable in the Watch window, a plus (+) or a minus
sign () appears in the Name column. You can use these boxes to expand or collapse the variable data to see the data contained within the
variable. There are several ways to add variables to this window. Type, paste, or click in the first column of an empty row to enter the variable
name. You can also drag and drop variables onto the Watch window. To accomplish this, highlight the variable you want to drag, hold the
mouse down until a small box appears below the mouse cursor, and then drag it to the Watch window. This is helpful when you have several
nested structures and it saves you from having to type the entire variable. Also when you have nested structures, the pop-up tool tip sometimes
doesn't show the value. Another way to add a variable is to place the cursor on the variable, press Shift-F9 to bring up the Quick Watch dialog
box and click the Add Watch button to add it to the Watch window.
Call Stack Window
The Call Stack window displays the active functions on the stack. The function that is currently executing is at the top of the window. The
function that called the currently executing function is below that and so on. The window will also display function parameters along with
their values and types. This allows you to see all of the parameters that are passed along down the stack. This can be helpful in looking for an
unexpected value or a possible NULL or invalid value for a pointer. You can also move to the code for the different functions by
double-clicking the function that you want to view in the Call Stack window. This will bring you to the line of code where the function above
it was called. See the code and Figure 9-7 for an example. The call stack that is shown is from stopping inside Func2.
int Func2(int Val)
{
//the call stack is viewed from this line of code.
return (Val + 2);
}
int Func1(int Val)
{
return Func2(Val + 1);
}
int main()
{
int x = 5;
int Res;
Res = Func1(x);
return 0;
}
Figure 7: The Call Stack window displays the active functions on the stack
Variables Window
The Variables window displays the variables in a tree that are important in the programs current context. You cannot add variables to this
window as you could in the Watch window. As in the Watch window, you can expand and collapse variables with the plus (+) and minus (-)
signs. You can modify the value of a variable from the Value column. Also, the call stack can be viewed from the Context box.
There are three tabs on the Variables window. The Auto tab displays variables from the current and preceeding lines of code. The Locals tab
displays all of the local variables in the current function. The This tab displays the object pointed to by the this pointer. See the code below
and Figure 9-8 for an example of the Variables window.
int main(int argc, char* argv[])
{
int x = 0;
int i;
int Res;
for (i=0; i < 4; i++)
x = x + 3;
//the Variables window is shown from the line of code below.
Res = Func1(x);
return 0;
}
Figure 8: You can see all of the variables in the current function by using the Locals tab of the Variables window
Exercise 9-1 Using the Call Stack and Watch Windows
1. Create a new Win32 Console Application project named Chap9_1.
2. When asked What kind of Console Application?, select A Hello World Application.
3. Open the Chap9_1.cpp file.
4. Add the following functions:
int Func2(int Val)
{
//the call stack is viewed from this line of code.
return (Val + 2);
}
int Func1(int Val)
{
//Place a breakpoint on the line of code below.
}
5. Add the following code to the main procedure.
int x = 5;
int Res;
Res = Func1(x);
6. Right-click the line of code in the function Func1 and select Insert/Remove Breakpoint from the pop-up menu or press F9. Notice the
red button that appears next to the line. This will stop the application when it executes this line of code. A breakpoint suspends the execution
of the program at the specified line of code. This allows you to view how a program is executing a particular piece of code. We will cover this
later in the chapter.
7. From the Build menu, select Start Debug and select Go, or press F5.
8. When the debugger stops at the breakpoint, go to the View menu, select Debug Windows, and select Call Stack. (You can also press
Alt-7 or press the Call Stack button on the Debug toolbar.) If the Debug toolbar is not visible, select Customize from the Tools menu. Go to
the Toolbars tab and select the Debug box to turn on the Debug toolbar.
9. Notice that the top of the Call Stack window displays Func1(int 5).
10. On the Debug toolbar, click the Step Into button or press F11.
11. Notice that the top of the Call Stack window displays Func2(int 6) and the next line displays Func1(int 5).
12. Double-click the line containing Func1 in the Call Stack window.
13. Notice that a green arrow appears next to it in the Call Stack window. In the source file, a green arrow appears by the line of code that
called Func2.
14. Double-click the line that contains main in the Call Stack window.
15. Notice that a green arrow appears next to it in the Call Stack window. In the source file, a green arrow appears by the line of code that
called Func1.
16. On the Debug menu, select Go or press F5 to let the program finish executing.
18. When the debugger stops at the breakpoint, go to the View menu, select Debug Windows and select Watch, press Alt-3, or press the
Watch button on the Debug toolbar.
19. On the following line of code, where the breakpoint is set, right-click the Val variable and select Quick Watch from the pop-up menu.
20. When the Quick Watch window comes up, notice that Val = 5. Press the Add Watch button. This will add Val to the Watch window.
21. In the Watch window, double click the cell below Val to allow editing.
22. Enter Val == 6 and press enter. Notice this expression is 0.
23. Press the Step Into button on the Debug Window or press F11. You are now in function Func2. Notice that Val = 6 in the Watch window,
and the expression Val == 6 is now 1.
24. Press the Stop Debugging button on the Debug toolbar, or press Shift+F5, to terminate the program.
Using Depends
The IDE has many debugging features available. Many of the features can be accessed from the Debug, Build, View, and Edit menus. The
most common of these debugging commands can also be accessed by the Debug toolbar.It can also be used for general information about
modules in an application. The Depends tool is shown in Figure 9-9.
Figure 9: The Depends tool can assist you in determining the dependencies of file types
For troubleshooting purposes, the Depends tool can be used to detect files that are required by a module, but cannot be found. It can find files
that arent Win32 compliant or files that are corrupt. It can find import and export mismatches such as when imported functions are not
resolved. It can even find circular dependencies. Another common error is when a DLL cannot be found at a specified path. Depends can find
the complete path of all the modules being loaded for an application so you can check to see if the DLL is in the path being searched.
Depends can also be used for general information purposes. It can show all the modules required for an application. This can help you in
determining if you have included all required files in your setup program. It can list the functions that are called in each module by other
modules. This can help you understand why a module is being linked, and help you to remove modules that are not needed. The following
information is included for each module found:
Full path to the module file
Time and date of the module file
Size of the module file
Attributes of the module file
Type of machine that the module was built to run on
Type of subsystem that the module was built to run in
Whether or not the module contains debugging information
The preferred base load address of the module
The file version found in the modules version resource
The product version found in the modules version resource
The image version found in the modules file header
The version of the linker that was used to create the module file
The version of the operating system (OS) that the module file was built to run on
The version of the subsystem that the module file was built to run in
A possible error message if any error occurred while processing the file
Exercise 9-2 Using the Depends Tool
1. Open the Depends tool. It can be opened from Start | Programs | Microsoft Visual Studio 6.0 | Microsoft Studio 6.0 Tools | Depends.
Notice the window title says Dependency Walker.
2. From the File menu, select Open or click the Open button on the toolbar.
3. Find the MSDEV.EXE file and click open. Notice the tree view in the top left pane. If the tree is not expanded, right-click MSDEV.EXE
and select Expand All from the pop-up menu.
4. In the bottom pane, the dependent modules are listed with information for each module. Click each column header. Notice that the list
can be sorted by each column.
5. Notice the top-right pane. These are import functions.
6. Notice the bottom-right pane. These are export functions.
7. In the top-left pane, right-click MFC42.DLL, and select Full Path from the pop-up menu. Notice all of the modules are now listed with
the full path to where they are located.
8. In the top-left pane, double-click MFC42.DLL. Notice a Quick View window opens up. This will contain technical information about
the selected file.
9. From the File menu, select Exit to close the Depends tool.
Using Spy++
Spy++ is a utility that has windows to view the systems processes, threads, windows, and window messages. To start Spy++, go to the Tools
menu and select Spy++. When Spy++ starts, a tree view of the windows and controls opens in the system. Spy++ is shown in Figure 9-10.
You can also open views for messages, processes, and threads. To open a view, go to the Spy menu and select the view you want to open. The
tree views can be expanded and collapsed by clicking the + or symbols to find the desired object.
Figure 10: Use the Windows view of the Spy++ tool to find properties of open windows
Windows View
The Windows view can be used to find windows that are open in the system and view the properties of them. The Windows view has the
Desktop as the top window. All other windows are child windows to the Desktop. You can find windows by scrolling though the view and
expanding the tree as needed. You can see more detailed information for a window by double-clicking the desired window. You can also use
the Window Finder tool to find windows. The Window Finder tool is shown in Figure 9-11. To use this tool, arrange your windows so that
you can see both the window you are looking for and Spy++. From the Spy menu, select Find Window. Click the Finder tool, and drag it to
the window for which you want to see the properties. As you drag the mouse over a window, the properties of that window will be displayed
on the Window Finder tool. If you know the handle of a window, you can also use that to find a window. Select the Hide Spy++ check box to
help find a window. This will minimize Spy++ to get it out of your way.
Figure 11: The Spy++ Find Window dialog box displays the properties of a window as you drag the Finder tool over it
The Window Properties dialog box contains five tabs: General, Styles, Windows, Class, and Process. The General tab contains information
about the windows caption, the handle, the dimensions of the window, and more. The Styles tab displays the window display codes. The
Windows tab shows the handles for the Next, Previous, Parent, First Child, and Owner Window. To see the properties of any of these
windows, just click the handle link. The Class tab displays information about the window class, name of the menu, icon handle, cursor handle,
and handle for the Background. The Process tab displays information about the Process and Thread IDs.
Processes View
The Processes view is used to display information about what processes are running on the system and view information about those
processes. The Processes view is shown in Figure 9-12. Processes are identified by their module names. The Processes view tree can be
expanded to see threads that belong to each process. To search for a particular process, with the Processes window in the foreground, go to the
Search menu and select Process. When the Process Search dialog box comes up, type the process ID or a module name to search on. Then
choose either up or down for the direction of the search.
Figure 12: Use the Processes View in Spy++ to display information about the processes that are running on a system
Threads View
The Threads view displays a tree of all of the active threads associated with windows. The Thread ID and module name are shown for each
thread. Processes are displayed in this view. From this view, you can search for threads by the threads ID or module name. You can view the
properties for a particular thread by double-clicking it. This will bring up a dialog box which will display the module name, thread and process
ID, and the threads current and base priority. The Threads view with a Properties dialog box is shown in Figure 9-13. This can be especially
helpful if you suspect that a low priority for your thread is causing it to not run as expected.
Figure 13: The Threads view in Spy++ allows you to search for active threads and displays their properties
Message View
The Message view allows you to see the messages associated with a thread, process, or window. Messages are what make the graphical user
interface (GUI) in Windows work. Everything you do with the mouse, keyboard, or other device is represented by a message. For example,
when you move your mouse, WM_MOUSEMOVE messages are created to indicate where the mouse is. Also, when you click a button, a
WM_LBUTTONDOWN message is created when the button goes down. The Messages window allows you to see the message stream being
used by the selected thread, process, or window. By capturing the messages for a process, you can view the initialization of all windows. The
first column contains the window handle, and the second column contains a message code. The third column contains the decoded message
parameters and return values. When the Messages view is first opened, an options dialog box opens allowing you to select the window to
view, and the types of messages to log. You can also start and stop the logging of messages and format the Messages view. The Messages
view is shown in Figure 9-14.
Figure 14: You can select the types of messages that you want to log from the Messages view in Spy++
Exercise 9.3 Using Spy++
1. Open the Chap9_1 project you created in Exercise 9-1.
3. On the Tools menu, select Spy++.
4. Notice the Windows view appears. If the Windows view is not visible, on the Spy menu, select Windows or press Ctrl-W.
5. Find the Microsoft Spy++ window and double-click it to see the properties of the window.
6. Click Close to close the window.
7. Click the + symbol next to the Microsoft Spy++ window to expand the tree.
8. Click the + symbol next to the MDI Client window to expand the tree. Notice the Windows window. Keep expanding this tree until you
get to the bottom. Notice the window is a list box.
9. Arrange your windows so that you can see Chap9_1.cpp in Visual C++ and the Spy++ tool.
10. On the Spy menu, select Messages. Notice the Message Options dialog box appears.
11. Click the Finder tool and drag it to the Chap9_1.cpp window.
12. Click OK on the Message Options dialog box.
13. Move the mouse over the Chap9_1.cpp window and notice the Messages view displaying the mouse and cursor messages.
14. On the Messages menu, select Stop Logging.
15. Close the Spy++ tool.
Integrated Debugger
The integrated debugger can be used to find bugs in executables, DLLs, and ActiveX controls. One of the ways to check how your code is
executing is stepping through your code one line at a time. If you dont want to step through your entire program, you can set a breakpoint on
a particular line of code. This will cause the program to stop execution at that line of code. We have used some of these features in earlier
exercises in this chapter. We are going to cover how to step through your code and using breakpoints in more detail in this section.
Breakpoints
First, lets talk about setting breakpoints. You can set one or more breakpoints to stop execution at the point where you want to debug your
program. You can also set breakpoints when certain conditions exist. After the program has stopped, you can then inspect your code to look
for problems. To set and view breakpoints, you can use the Breakpoints dialog box. The Breakpoints dialog box has three tabs: Location,
Data, and Messages. To open the Breakpoints dialog box, from the Edit menu, select Breakpoints, or press Alt-F9.
The Location tab of the Breakpoints dialog box allows you to set a breakpoint by source code line number, memory address, register, or
function name. This tab is only available in the Enterprise Edition of Visual C++ 6.0. Enter this information in the Break at text box. The
existing breakpoints are displayed at the bottom of the dialog box. If you click the Edit Code button, it will take you to the line of code where
the breakpoint is set. The Location tab is shown in Figure 9-15.
Figure 15: The Location tab of the Breakpoints dialog box provides options for setting breakpoints
If you are not sure how to enter the information in the Break at textbox, click the button with the arrow next to it for more options. When you
click this button, you will see a pop-up menu with two options. The first is the line number that the cursor is currently at in your project.
Select this to add a breakpoint at the current line. The other option is advanced. If you click this, it will bring up the Advanced Breakpoint
dialog box. You can enter the location (which is the same information as the Break at text box), or enter information in the Context section.
This allows you to set a breakpoint outside of the current scope by selecting a function in a different source or executable file. The Advanced
Breakpoint dialog box is shown in Figure 9-16.
Figure 16: Use the Advanced Breakpoint dialog box to set a breakpoint outside of the current scope
You can also set the breakpoint based on a condition. To do this, click the Condition button. This will bring up the Breakpoint Condition
dialog box. This will allow you to enter an expression to break on at the location specified. When the expression evaluates to true, the program
will break. You might want to check for a variable equal to a certain value. If you enter an expression you can also enter how many times to
skip this breakpoint before stopping on the breakpoint. You can also set the breakpoint based an array element being changed. Set the
expression to an array index (for example, YourArray[0]), and enter how many elements in the array you want to watch (one to number of
elements in array). The Breakpoint Condition dialog box is shown in Figure 9-17.
Figure 17: The Breakpoint Condition dialog box allows you to set a breakpoint based on a condition
The Data tab in the Breakpoints dialog box allows you to enter an expression within the current scope. You can set a breakpoint for when a
variable changes or an expression evaluates to true. You can also set a breakpoint for an array element changing or an expression being true,
as you could on the Location tab. The Data tab is show in Figure 9-18.
Figure 18: You can use the Data tab of the Breakpoints dialog box to stop execution when a specified expression is true
The Messages tab allows you to set breakpoints when specified window procedure messages are received. The Break at WndProc list box
contains the exported functions in your project. The Set One Breakpoint for Each Message to Watch list box contains messages to break on.
You can select multiple messages as desired. The Messages tab is show in Figure 9-19.
Figure 19: You can set breakpoints for window procedure messages with the Messages tab of the Breakpoints dialog box
At the bottom of each tab is a list of existing breakpoints. You can edit and remove these breakpoints. To edit them, select one and the
properties for that breakpoint will be displayed. Edit the properties as desired. To remove breakpoints, highlight the breakpoint and click the
Remove button. Click the Remove All button to remove all of the breakpoints.
You dont always have to use the Breakpoints dialog box to set breakpoints. You can place the cursor on a line of code and press F9, click the
Insert/Remove button on the Build toolbar or right-click a line of code and select Insert/Remove breakpoint. You can use the Find box on the
Standard toolbar to search for a function or label and click the Insert/Remove button to set the breakpoint. You can also use the Call Stack
window to set breakpoints with the Insert/Remove button or by pressing F9.
Stepping through Code
Now that we can set breakpoints, lets talk about stepping through your code. Once you have stopped the execution of your application, you
can step through lines of code to determine if your code is doing what you expect. While you are stepping through your code, you can use the
debug windows to see the values of variables, expressions, the call stack ,and parameters passed, and so on. You can modify variable values
and view debug output.
To step through your code, use the Debug menu or the Debug toolbar. To move to the next line of code, use Step Into or Step Over. When you
get to a line of code with a function call, these two commands have different effects. The Step Into command will go to the first line of code
inside the function being called. Use this command when you want to see how the function executes. The Step Over command will go to the
line of code following the current line of code. Use this command when you know the function is executing correctly. It will not go into the
function being called.
If you are inside a function, you can use the Step Out command to exit the function and go to the line of code after the line that called the
function. Use this command when you have reached the part of a function that you wanted to check and dont want to step through the rest of
the function.
Another command is Run To Cursor. This command will execute the program until it reaches the line of code the cursor is on. This can be
helpful for skipping loops so you dont have to step through 1000 iterations.
The Step Into Specific Function command allows you to view the code inside a function that you specify. This is used when there are nested
function calls on the same line of code. This allows you to view how a function executes without having to step through all of the functions.
Edit and Continue
A new feature added to Visual C++ 6.0 is Edit and Continue. If you have used Visual Basic, you are already familiar with this feature. This
allows you to edit the source code while debugging and apply these changes without having to rebuild the application. The application will be
returned to the state that it was in when the bug occurred and you can see if your change fixes the bug. If you have compile errors, the changes
are not applied, and your compiler errors are displayed in the Output window. You can change variable values, expressions, and function
parameters, and you can even add new functions and call them in the code that you are debugging. When you are finished editing the code,
select Apply Code Changes from the Debug menu.
You can configure your project to automatically perform the Apply Code Changes command when a Debug command is executed. This way
you dont have to keep running the command every time you edit the code. To set this option, on the Tools menu, select Options. When the
Options dialog box comes up, go to the Debug tab and select Debug Commands Invoke Edit and Continue. The Debug tab on the Options
dialog box is shown in Figure 9-20.
Figure 20: The Debug tab on the Options dialog box contains options that allow you to change the code and then continue debugging
Exercise 9-4 Using Breakpoints and Stepping through Code
int Func2(int Val)
{
int x = 6;
Val += (x / 2);
return Val;
}
int Func1(int Val)
{
int x;
x = Func2(Val);
return x;
}
5. Add the following code to the main function:
int y = 4;
int res;
res = Func1(y);
printf("Func1 returned %d\n", res);
getchar();
6. Place the cursor on the following line of code in the main function and press F9 to set a breakpoint. Notice the red dot that appears next
to the line of code.
res = Func1(y);
7. From the Edit menu, select Breakpoints or press Alt-F9. Notice the breakpoint at the bottom of the dialog box.
8. Place the cursor inside the Func2 function.
9. Go to the Data tab and click the arrow button to bring up the Advanced Breakpoint dialog box.
10. In the Expression text box, enter Val == 7.
11. In the Function text box, enter Func2.
12. In the Source File text box, enter CHAP9_4.CPP.
13. Click OK to close the Advanced Breakpoint dialog box. Notice the breakpoint has been added at the bottom of the Breakpoints dialog
box. It should appear similar to: when {Func2,chap9_4.cpp,} Val == 7.
14. Click OK to close the Breakpoints dialog box.
15. From the Build menu, select Start Debug, and select Go or press F5 to start the program. Notice the program stopped at the breakpoint in
the main function.
16. Click the Step Into button on the Debug toolbar or press F11 twice to step into the Func1 function. This will bring you to the following
line of code.
x = Func2(Val);
17. Click the Step Over button on the Debug toolbar or press F10 to step over the Func2 function call. Notice that you received a message
box for the breakpoint that we set when Val == 7.
18. Click Ok. Notice it took you inside the Func2 function.
19. Hold the mouse over the variable Val. You should get a tool tip showing Val = 7.
20. If the Variables window is not visible, from the View menu, select Debug Windows, and select Variables. Notice the variables Val and x
are displayed.
21. Press F5 to continue the program. Notice the console displays Func1 returned 7.
22. Press the Enter key to finish the program.
23. From the Build menu, select Start Debug, and select Go or press F5 to start the program.
24. After it stops at the breakpoint, press F5 and click OK when you get the Breakpoint message box.
25. On the following line of code, change Val to 15. On the Debug menu, select Apply Code Changes, or make sure that the Debug
Commands Invoke Edit and Continue option is selected on the Options dialog box, as described earlier in the chapter. Press F5 to continue the
program.
return Val;
26. Notice the console now displays Func1 returned 15. This is an example of using the new Edit and Continue feature.
27. Press the Enter key to let the program finish.
MFC Macros Used to Debug Applications
The MFC library contains macros that can be used for debugging applications during run-time. These macros can be used to display
debugging information during run-time. This can make the debugging process much less difficult. A couple of the most commonly used
macros are assert and trace. These macros allow you to check for logic errors and to output diagnostic data. The first step in using these
macros is to include the CRTDBG.H file in which they are defined.
ASSERT
The ASSERT macro allows you to check for logic errors during program execution. When the expression is false or 0, it prints a message and
aborts the program. The message includes the expression checked for, the source file name that the error occurred in, and the line number in
the source file. Where the message appears depends on the type of project. For console applications, the message goes to stderr. For a
windows application, the error is displayed in a message box with an OK button that will terminate the program. If the application has been
linked to the debug versions of the run-time library, the message box will have three buttons, Abort, Retry, and Ignore. If you press Abort, the
program is terminated. If you press Retry, the debugger is opened and you can then debug the application. If you press Ignore, the assert is
ignored and application execution continues. Be careful though, you could have unexpected results by ignoring the error condition.
When you have finished debugging and testing your application, build a release version of your program. This will use the run-time libraries
that do not contain the debug versions of functions, and asserts will be ignored. This will significantly increase the performance of your
application. You dont want your program aborting on an assert when your customer is using it, you should have ways of handling errors in
the code. Assert checking can also be turned off by defining NDEBUG with a #define. It must be defined before the ASSERT.H include
statement. Assert is used to notify you when there is an unexpected error. As an example, lets say you are programming a linked list and you
are deleting a node from the list. You could use an assert to check for the node pointer being NULL. Obviously, you shouldnt be trying to
delete a node from a NULL pointer. A word of caution, do not use assert for all of your error checking. Remember that ASSERT is ignored in
the release version of your application. Do not put code in the assert statement. For example, if you set a variables value inside the ASSERT
statement, when the release version runs, that variable would not be set. See the following code for an example.
ASSERT((x = ComputeValue()) == 0);
One solution to the preceding problem would be to use the VERIFY macro. It is the same as ASSERT, except the expression is executed
without the assert test being performed in the release version. If there is any error checking that should always be performed, use error
checking that will handle the error. You would not want the assert functionality in your release version anyway because the unneeded
overhead would cause a performance hit. Also, imagine the displeasure of your customers if they received a dialog box informing them of the
error and then the application terminated. Your application should handle all errors gracefully. You can also use the ASSERTE macro. It is the
same as the ASSERT macro, except it also displays the expression that was evaluated.
One of the new library functions in version 6.0 is the debug report function for logging errors and warnings during application execution. The
ASSERT macro calls the _CrtDbgReport function for sending messages for debugging. These messages can be sent to a file, the Visual C++
debugger, or a debug message window. The message can also include the source file name, the line number in the source file, and the .EXE or
.DLL filename. The message can be formatted similar to the printf function using a format-control string.
TRACE
The TRACE macro allows you to send formatted strings to a dump device. The formatting of the trace string is the same as printf. The strings
can be dumped to a file or debug monitor. To turn on tracing, you must define _DEBUG, use the debug version of your application, enable the
afxTraceEnabled flag, and set the afxTraceFlags to determine the level of detail output. These flags can be set using the tracer.exe tool. This
tool modifies the AFX.INI file. You can use trace to display variable values or any other logging functionality that you require.
Be careful in the use of TRACE. Dont output too much information or you wont be able to sort through it. Imagine sifting through a file
over a megabyte in size looking for the answer to your problem. Try not to put TRACE statements inside loops that iterate a large number of
times. When different developers are working on different units, you will have to sift through all of their TRACE statements also. One
common solution is to use conditional compilation for each developer. TRACE is useful when you need to see a sequence of events that you
cannot create by stepping through the code. Put TRACE statements at the beginning and end of critical functions and where critical events
occur.
DEBUG_NEW
The DEBUG_NEW macro is used to help find memory leaks. It is used in place of the new operator in the debug version. This macro tracks
the filename and line number for each object allocated. When you want to see the memory allocations, call DumpAllObjectsSince to view all
objects allocated with the source filename and the line number where they are allocated. You can review this list to check objects allocated
and determine which ones should have been freed and to see if any objects are lost in memory. Use the following macro to define the new
operator to use the DEBUG_NEW macro. You still use the new operator in your code, but it will then use DEBUG_NEW to allocate the
object. This will add debugging information to each allocation. It is only used in the debug version. In the release version, DEBUG_NEW is
resolved to a new operator and there isnt any debugging information saved. Therefore, you dont get a performance penalty in the release
version.
#define new DEBUG_NEW
Other Commands
Some less common MFC macros used for debugging are listed in Table 9-3.
Macro Description
ASSERT_KINDOF
Checks to see if an object is of a specified class or derived from the specified
class
ASSERT_VALID Checks the validity of an object by calling its AssertValid member function
TRACE0 Same as TRACE but the format string has no arguments
TRACE1 Same as TRACE but the format string has one arguments
TRACE2 Same as TRACE but the format string has two arguments
TRACE3 Same as TRACE but the format string has three arguments
VERIFY
Similar to ASSERT but evaluates the expression in the release version of the
library as well as in the debug version
Table 3: Descriptions of MFC Macros
Exercise 9-5 Using the ASSERT Macro
4. Add the following code:
#include "crtdbg.h"
int Func2(int Val)
{
Val += 3;
return Val;
}
int Func1(int Val)
{
_ASSERT((Val = Func2(Val)) != 0);
return Val;
}
5. Add the following code to the main function:
int x = 3;
x = Func1(x);
printf("x = %d\n", x);
getchar();
6. From the Build menu, select Start Debug, and then select Go or press F5 to run the application. Notice that the application displays x =
6.
7. Press Enter to let the application finish executing.
8. Now lets set the application to run in release mode. From the Build menu,. Select Set Active Configuration. Select Chap9_5Win32
Release and click OK.
9. From the Build menu, select Execute Chap9_5.exe or press Ctrl-F5 to run the application. Notice that the application displays x = 3. This
is because the code in the ASSERT macro is not executed and therefore the function Func2 is not executed.
10. Press Enter, and then press any key to allow the application to finish executing.
Elements of a Test Plan
Testing is different from debugging. Debugging is the process of fixing bugs. Testing is the process of finding those bugs. There arent too
many software engineers who enjoy testing. It is also difficult for developers to do extensive testing because the developer already knows how
the application should work. However, testing is crucial to the success of an application. Testing is needed to find bugs in a program. I know,
good programmers wouldnt have any bugs to find.
Testing is also commonly cut short due to delivery deadlines. In todays rapid application development (RAD) environment, testing is even
more necessary. Two important tools needed for testing are source control, such as Visual Source Safe, and a bug tracking system. Bug
tracking tools can be as simple as a spreadsheet or as intricate as some third-party tools. This allows everyone on the team to know what bugs
there are, and the status of those bugs. This is a broad area and we will only cover the areas needed for the exam. There areas of testing we
will cover are Beta testing, Regression testing, Unit testing, Integration testing, and Stress testing.
All software contains bugs when it is released. You want to ensure that you know what those deficiencies are. If you werent able to fix the
bug before release, make sure you have a work-around in place. This should only be done for what is deemed a rare occurrence. This is not
ideal, but it is much better than your customer calling you and you have know idea how to solve the problem. You should include any
work-around in your release notes. You cannot account for everything, but the more you do account for, the better.
Beta Testing
Beta testing of an application allows testing by users who are not part of or do not have any ties to the development process. The testers are
completely independent of the development of the application. You can accomplish beta testing with a test team internal to the company or by
releasing beta software to the general public as Microsoft does. It allows you to receive unbiased feedback on bugs, features, or any other
aspects of your application. This allows a completely independent test environment for your application.
When you beta test your application, choose a group of advanced users who are more competent and knowledgeable. You dont want to be
bombarded with simple questions. Choose users who know what you are trying to achieve with your application. This will also allow your
application to be tested for those unknown, random configurations. For instance, users will have different computer. There will be different
operating systems, processors, motherboards, amounts of memory, hard drives, and so on. You cannot setup a test bed for every possible
computer that your application will be run on unless you are in a very controlled environment.
Evaluating the Need for Beta Testing
When do you need to perform beta testing? Beta testing should always be performed whether you are releasing beta versions of your product
to some of your advanced customers or to a group of employees who will be using your application internally. There are some instances
where beta testing is even more critical. If your application will be used by a wide range of users or different computer configurations, then
beta testing can help you work out problems before your release, instead of after releasing it. These types of applications would need more
extensive beta testing than an internal-use program, although you should perform some level of beta testing on all applications.
Use the following checklist to help determine when to beta test your application. All applications should have some BETA testing.
Different operating systems (Windows 3.1, Windows 95/98 and Windows NT)
Different computer configurations (CPU, RAM, hard drive space, CD-ROM, sound, video)
Different levels of users (that is, from the beginner to the expert)
Different languages as necessary
Regression Testing
Regression testing is repeating previous testing to show that a change to the application does not affect other aspects of the application. The
results of testing parts of the application that were not changed should be the same as they were in previous tests. Regression testing is also
important when you have earlier versions of your product released. You will have to test to ensure that you are completely backwards
compatible, as necessary. As an example, if you updated your database structure, you would need to ensure that your new version could still
read the old data and convert it to the new database. Also, if you have more than one version of your application and you update a DLL, you
have to test to ensure that the DLL will work with all versions. Regression testing is commonly performed by a software test engineer.
Unit Testing
Unit testing is testing the smallest part of an application that can be tested. This involves more than making sure that your unit will compile. It
is testing to show functionality that is required has or has not been met. Unit testing is generally performed by the programmer. The testing
should validate that the unit completely meets the requirements for which the unit is designed. Another important area to check is how your
unit handles invalid data.
Unit testing should start at the same time you start writing your code. This will involve writing test code for your unit. When you start creating
your interfaces, you can start testing those interfaces. Then as you add functionality, you can test it along the way. If you wait until you
believe you are done, you might have to redesign some areas to solve unexpected problems. If you had tested along the way, chances are, you
would have discovered the problem much earlier and wouldnt have to re-write any code.
Use the following checklist for areas to check in unit testing:
Meets requirements for which it was designed
Performs the functionality desired
Handles invalid data (data to large, NULL values, user entry)
Handles expected steps being out of sequence
Does not crash
Integration Testing
Integration testing is used to demonstrate that all of the units work together. Just because unit testing is completed, it does not guarantee it will
work correctly with other units of an application. This is especially true of large applications where there are many different programmers
working on it.
Use the following checklist for areas to check in integration testing:
Units can interface with each other correctly
All units meet overall application functionality and requirements
Handles missing modules gracefully
Uses different paths for the application and support files
Stress Testing
Stress testing places the highest possible loads with the lowest possible resources available to an application. This could be a high rate of data
input on a machine with the minimum required resources. This can also help in determining the minimum requirements for an application.
Incorporating Stress Tests
Microsoft Visual Studio comes with a tool to assist in stress testing. It is called Stress! It uses up system resources for low resource stress
testing. It can acquire resources such as the global heap, user heap, GDI heap, disk space, and file handles. You can configure the Stress tool
to allocate resources in fixed, random, and message-dependent allocations. It also provides logging options to help locate and reproduce bugs.
You can preconfigure it by setting the options that you desire in a STRESS.INI file. The Stress tool is shown in Figure 9-21.
Figure 21: The Stress tool assists you with stress testing
When stress testing applications, you want to see how your application performs under different types of conditions. If your application gets
an error due to a stress condition, it should notify the user of the problem and either allow the user to fix the problem if possible, or exit
gracefully. Your program should check each memory allocation, check for free disk space before writing to a file, and so forth. This is what
the tester will be looking for. Following is a checklist of items that should be tested during the stress test:
Minimum required CPU
Minimum required RAM
Amount of free disk space
Minimum CD-ROM drive speed
Maximum data load that the application is required to handle
From the Classroom
Don't Undervalue the Process of Debugging Your Application
Throughout this chapter you have learned various debugging techniques and the elements of a test plan. These elements are important to
provide you with the tools you need to thoroughly test your C++ applications. In many projects, software testing can account for 30 to 50
percent of software development costs. But why is testing so important? And how can we ensure that our software is properly tested?
The main goal of testing is to ensure that we deliver a quality software product. Quality software must satisfy user and system requirements in
areas of reliability, functionality, application performance, and system performance. Because software quality has a variety of measures, it is
important to incorporate many different debugging techniques and types of tests into your test plan. Verifying your software's reliability may
include using debugging functions during unit testing of a class to ensure that it does not leak any memory. Test cases can be developed for
each feature in your application's feature set to ensure that all the necessary functionality is included in the application. Stress testing may be
performed at the application and system level to ensure your software performs well under typical and maximum load situations.
Another good reason to test software completely is to reduce the number of errors that you have to fix after the software is deployed. It always
costs more to fix a problem after software deployment than it does to fix the problem before the software is released to the users. This is in
addition to the decrease in user satisfaction that accompanies software products requiring many post-release fixes.
Ensuring that software is thoroughly tested comes down to one thing: planning. As you define the requirements of your application and create
a development plan, you should also be defining your test plan. The first part of the test plan is to perform risk analysis of your system. Use
this analysis to define your test objectives. The highest risk elements of your application should be tested, and verified, early on in the
development cycle.
A good test plan is also one to which you adhere throughout the software development cycle, not just before your software ships. Coding and
testing in incremental fashion will identify defects early, so they can be fixed early, before fixing the error produces a "ripple effect" (you end
up breaking multiple features built on top of the faulty code). Finally, develop a plan for tracking and managing defects. Armed with the
debugging tools and features of Visual C++ 6.0, and a plan, you can deliver quality C++ applications.
Visual C++ contains many features to assist you in debugging and testing your application. Debugging is fixing errors in your code. Testing is
finding those errors in your code.
You can make different versions of your application, a release version and a debug version. For the debug version, Visual C++ comes with
debugging libraries which contain debug versions of memory functions to help find memory leaks. There is debugging support in the run-time
libraries to allow you to step into run-time functions. It also creates .PDB files to hold debugging information for your application. The
debugging overhead is not used in the release version.
Visual C++ provides many debugging features in the IDE. It provides commands for viewing different types of data and controlling the
execution of your program. These include windows for viewing variables, expressions, the stack, memory, registers, and assembly code.
Use the Depends tool to assist you in determining the dependencies of .EXEs, .DLLs, .OCXs, .COMs and other file types. This can be used
for debugging or for finding general information about your application.
The Spy++ tool is a utility that has windows to view the systems processes, threads, windows, and window messages. It also comes with a
Finder tool so you can use your mouse to choose an application for which you want to view the properties.
The integrated debugger is a very useful tool in the debugging process. It allows you to set breakpoints for stopping program execution at
specified points in your code and allows you to step through your code to determine if your program is executing correctly. It also has a new
feature called Edit and Continue. This allows you to edit code while your program is stopped and continue execution from where you stopped
without having to rebuild your application and restart it from the beginning.
The MFC library contains some macros that can be used for debugging. The ASSERT macro allows you to check for unwanted conditions in
your code and stop program execution. The TRACE macro allows you to output messages to aid in debugging your application. You can use
it to show program flow and data values.
There are many phases to the testing process. Beta testing allows pre-release testing of your application. Regression testing is used to ensure
backward compatibility and verify that you didnt break other aspects of your application. Unit testing is usually performed by the developer
to make sure the unit fulfills what it was designed for. Integration testing verifies overall application functionality. Integration testing is
normally performed by a tester and it brings all of the units together to see how they operate as a whole. Stress testing sees how your
application performs under adverse conditions.
Two-Minute Drill
Debugging an application allows you to find errors in your application. Errors can be programmatic or logical.
When you create a project, both a debug version and a release version are created.
Visual C++ includes debugging support in the run-time library. This allows you to step into a run-time functions code and contains
functions to help locate memory leaks and other memory problems, and to view the heap.
The debug libraries include debug versions of malloc, free, calloc, realloc, new, and delete. These can be used for finding memory leaks.
The IDE has many debugging features available. Many of the features can be accessed from the Debug, Build, View, and Edit menus.
The most common of these debugging commands can also be accessed by the Debug toolbar.
The IDE has many debugging features available. Many of the features can be accessed from the Debug, Build, View, and Edit menus.
The most common of these debugging commands can also be accessed by the Debug toolbar.
For troubleshooting purposes, the Depends tool can be used to detect files that are required by a module, but cannot be found.
Spy++ is a utility that has windows to view the systems processes, threads, windows, and window messages. To start Spy++, go to the
Tools menu and select Spy++.
The integrated debugger can be used to find bugs in executables, DLLs, and ActiveX controls. One of the ways to check how your code
is executing is stepping through your code one line at a time. If you dont want to step through your entire program, you can set a breakpoint
on a particular line of code.
The MFC library contains macros that can be used for debugging applications during run-time. These macros can be used to display
debugging information during run-time.
Testing is different from debugging. Debugging is the process of fixing bugs. Testing is the process of finding those bugs.
Beta testing of an application allows testing by users who are not part of or do not have any ties to the development process. The testers
are completely independent of the development of the application.
Regression testing is repeating previous testing to show that a change to the application does not affect other aspects of the application.
The results of testing parts of the application that were not changed should be the same as they were in previous tests.
Unit testing is testing the smallest part of an application that can be tested. This involves more than making sure that your unit will
compile. It is testing to show functionality that is required has or has not been met.
Integration testing is used to demonstrate that all of the units work together. Just because unit testing is completed, it does not guarantee
it will work correctly with other units of an application.
Stress testing places the highest possible loads with the lowest possible resources available to an application. This could be a high rate of
data input on a machine with the minimum required resources. This can also help in determining the minimum requirements for an
application.

Chapter 10: Distributing an Application
Creating a Setup Program.. 3
Registering COM Components. 15
Using .cab Files. 18
Planning Application Distribution. 22
Systems Management Server Tools. 26
Accessing Client Access Points and Distribution Points. 27
Using Programs. 29
Creating a Setup Program.. 33
Two-Minute Drill 36
Installing an Application
Packaging and Distributing an Application
Using Microsoft Systems Management Server to Distribute an Application
Installing and Uninstalling an Application
Using Zero Administration for Windows (ZAW) to Distribute an Application
This section of the exam deals with the ways you can package and distribute your application. The first thing a user will see when receiving
your application is the installation program. Although this is a completely different program than the main application, this is where the user
will form their impression of the application. You cant gain much praise from an installation program, but you can make a user very angry
with it. Luckily, Microsoft provides a version of the popular Installshield program with most versions of their Visual C++ compiler. This
makes it easier to create an installation program to handle installing and uninstalling your application; which are requirements for a Microsoft
logo on your software.
This chapter is broken down into several of the important factors to keep in mind when preparing your application for release. There are
several factors to think about when packaging an application, as there are many different paths you can take depending on the environment
and target audience for the software. These same factors apply when you decide which way you will distribute your application to the targeted
audience. We will cover each of these issues in this chapter.
Installing an Application
Now that you have done the grunt work of finally getting your application finished, there is one hurdle that remains. This hurdle is packaging
your application and distributing it. Keep in mind that your application has been coded, debugged, and tested.
Your installation will depend largely on the environment your application is being used in and who the people are that will be using it. For
instance, if your application is an internal tool for use by a group of professionals, your application will not need to have a very elaborate and
fancy graphical installation process. Also, many computers are built from the same image within corporations, so hardware compatibility will
not be much of a concern. As for the distribution method, if you are distributing to the public you dont know which files they have on their
hard disk drive. You will need to include these files in the distribution disk and install them if necessary from your setup program. A good
way to check which files your program is dependant on is to use Quickview. To see which files your application is dependant on, you can
right-click your executable and choose Quickview if it is installed. A sample is shown in Figure 10-1. Quickview comes with Windows and
can be installed in accessories from control panel.
Figure 1: Use Quickview to show an .exe files dependencies
Now that you know which files your application will depend on, you can package them with your application and have your setup program
decide whether or not to install them. Now its time to talk about this setup program using a tool Microsoft has provided with the Visual C++
integrated development environment (IDE).
Creating a Setup Program
Your program is complete. You have sent it through the quality assurance process and ironed out the major kinks. Now you want to create the
setup program so people can use your application!
Microsoft packages a light version of InstallShield with their Developer Studio application development packages. With this version of
InstallShield you can create a setup program for basic applications. For more features, a full version of InstallShield is available for purchase.
We will look at creating a setup program for AppODBC1 here. First make sure you have InstallShield installed on your computer. If it isnt
you can install it now, we will be waiting. The installation for it is located on your Visual C++ CD-ROM.
Exercise 10-1 Creating a setup program
1. Launch your InstallShield. Typically this is found in Start | Programs | Installshield for Visual C++ 6.0.
2. Double-click the Project Wizard to help guide you through creating your setup program.
3. The first screen you will see is shown in Figure 10-2. You can type the application name and company name. Your development
environment, of course, is Microsoft Visual C++. You can choose your application type in the next drop-down box. We chose Database
Application, because AppODBC1 was created as a database application. Other choices you have are: Finance Application, Internet
Application, Software Development Application, and Statistical Application. Most of these are self-explanatory, but Software Development
Application is less clear; this choice is used for general applications that dont fit the other choices. You also choose a version, which usually
is the same as the version of the application you made. Lastly, you can click the ellipsis button to open a browser window to choose the
location of your executable. Choose your executable and click Next.
Figure 2: The first step in the InstallShield Project Wizard is to enter information about your application
4. The next step is choosing the dialog boxes that will be presented to the user installing this application. You can see thumbnail views of
the dialogs on the lower-left side of the screen to quickly determine if you want the dialog to be in there without having to open each of them.
Here you will need to know who your target audience is and select the options for dialogs based on who they are. If this is an internal project,
you may not need a license agreement or custom setup options, nor will you have to choose a destination location. If this is a public
application you will want to make it as configurable as possible. We will build this as an internal database application and use the options
shown in Figure 10-3. Click next.
Figure 3: Choose the dialog boxes that the user will see during the installation of your application
5. Now you can choose which operating systems your application will support. Keep in mind that the less you choose the smaller your file
will be. Also, if this is an internal application to a company and you know all the workstations run Windows NT, you wont need to select as
many options. As for a consumer product, you will want to support as much as you can, because you cannot predict which operating system
your users will run. Even though this is an internal application I will still choose to support the most common operating systems, as shown in
Figure 10-4. You can pick multiple operating systems by pressing the Ctrl key while clicking them. After you have made your choices, click
Next.
Figure 4: Choose the operating systems that your application will support
6. For the next step, you can choose languages that your application will support if you plan to do localization. We will choose only
English because our company is in the United States. You can show sublanguages to get into further details. You can see all this in Figure
10-5. Click Next.
Figure 5: Select the languages in which you will create your setup
7. You can customize the setup types in the next dialog. I will give a run down of the options you have.
CompactCompact is usually selected when your distribution medium is a CD-ROM and you want the user to run the files from the
CD-ROM.
TypicalA typical install installs the program with the most common options that you would like to install. This usually does not require
a CD-ROM to run the program.
CustomCustom allows your users to choose which parts to install.
NetworkThis is for a network install and after it is installed, a connection to the network is not necessary to run the program.
AdministratorThis is a file that an administrator makes available for clients to download and install.
Network (Best Performance) This will install as a larger size than the next kind of install, but it will reduce the amount of network
calls.
Network (Efficient Space) This takes up less space on the users hard disk drive, but uses a lot of network traffic.
On the job: Network installations are increasingly more common in the workplace. If you are programming a database application, it is almost
necessary to give your users a network installation option. Also, if you program a shareware utility you may want to consider allowing
network installations; this may free you from having to make a separate site license installer if companies or universities decide to buy this.
We will choose the first three that were the defaults when we came to this screen. This dialog is shown in Figure 10-6. Click Next.
Figure 6: Select one or more setup types to include in your installation
8. Specifying components lets you group what the user sees when he is doing a custom setup. You can associate file groups with a
component and add, edit, or remove component types. InstallShield ignores an empty component. You may also set subcomponents. For
instance, if you have a database application and a data report application, you can specify these as components. As subcomponents, you can
make dlls, data files, and samples. That is one example of a common use of these components. Our application will not be that elaborate, so
you can add the file dependencies that you saw by using QuickView and customize the components however you please. My setup is shown
in Figure 10-7. Click Next.
Figure 7: Customize your components
9. File components are where files are grouped together in a logical order for installs. This installation will use Program Executable Files,
Shared Dlls, and Program Dlls. If you need to, you may specify different file groups. This dialog is shown in Figure 10-8. Make your choices
then click Next.
Figure 8: Select the file groups for your setup
10. The summary dialog box comes up next. You can now verify which options you chose to be sure they are correct. Now click finish and
we are almost done.
11. The InstallShield program has now created several files for you. In particular, it has created a scripting file called setup.rul, which is
shown in Figure 10-9. To complete the process we will set up our components, set up our file groups, and define our dialog resources.
Figure 9: InstallShield has created a script file for you
Working With Components
You should now click the components tab, it looks like a pie with a piece to the side, to bring up the components screen. Here you are
presented with several options. in Table 10-1, I will give a brief description of some of the important fields.
Field Description
Description Allows you to enter a description of the component.
Overwrite This allows you to specify the properties to determine
when the component will overwrite files. These
properties allow you to specify if you will overwrite if
your file is newer, overwrite always, or overwrite if
they have the same date.
Destination The location where the file will be placed.
Include in Build The uses for this may not be apparent, but if you are
building a demo and a release product, there are some
files that will be shipped with one and not the other.
This is convenient to let the file remain in the project
without it being used.
Required Components This sets up a relationship between components.
Included File Groups This lets you set up the relationship between
components and file groups.
Table 1: Component Options
Working With File Groups
Now you should click the file groups tab to bring up the screen shown in Figure 10-10. This is where you add the files that your application
will install. Right-click Links underneath the file group in which you want to add the file and choose insert file. A dialog box will open up
allowing you to choose files. This Figure 10-10 shows that we have added the program executable file of our application.
Figure 10: Add the files that your application will install
In this tab you will need to add all the files that you plan on installing. For example, if you distribute MFC40.dll, you probably will place this
in the Shared DLLs portion.
Working With Resources
Again, to start off, we should click the resources tab of the InstallShield. You can change the values in the string table to further customize
your setup application. My choices are shown in Figure 10-11. Some choices that would be good to change are: PRODUCT_VERSION,
COMPANY_NAME, COMPANY_NAME16, PRODUCT_NAME, and PRODUCT_NAME16. This gives a nearly complete setup program
for simple applications, and later you will need to package and distribute this. That will be covered later; we will now segue into registering
COM components.
Figure 11: Change the values in the string table to further customize your setup
Registering COM Components
If your application uses COM components, there are steps you need to perform to set them up. These components need to be registered
whether they are controls, containers, or servers. Now, I have said they need to be registered, so you should think of the Windows Registry.
Each type of COM component needs to be registered in a certain way, so applications will be able to find them. There are a number of entries
that each COM component must add to the registry. Luckily, InstallShield provides a very simple means to register your components upon
installation.
If you have made your component self-registering, you can specify this in the File Groups dialog; InstallShield will take care of calling the
appropriate functions to enter the information into the registry. In this way, InstallShield speeds up your registering of the COM components
that your program uses and you wont need to deal with it later.
When a .dll is self-registering, it will contain two functions to export. These functions are DllRegisterServer and DllUnregisterServer, for
registering and unregistering the component from the registry, respectively. When you specify a component to be self-registering in
InstallShield, this calls your DllRegisterServer when you install and DllUnregisterServer when you uninstall the application. You register
COM components into the registry for all applications to see them if needed. To manually add a .dll to the registry that contains these
functions, you may use REGSVR32 filename.dll to register and REGSRVR /u filename.dll to unregister. These commands are used from the
command prompt.
If you decide to programmatically register components in the registry you have many application programming interface (API) functions
available to aid you. First, a good understanding of what keys and values mean in the registry is important. Secondly, you should know where
to put these keys and values in the registry so they will be useful. Lastly, it is important to know what these keys and values should be. I will
cover these lightly now.
A key is an entry into the registry and can contain subkeys, which they usually do. A value is a string or numerical value associated with
certain keys. This is hierarchical in nature and can look like your windows explorer representation of your hard drive. In this comparison a key
would be like a folder, a subkey would be like a subfolder, and a value would be the name or number of files in that folder.
A special key in the registry is the class ID (CLSID). A CLSID is a large number that should be unique for any COM component you use.
This CLSID key in the registry is under HKEY_CLASSES_ROOT. This is where all COM components should be so that other applications
will be able to see them as well.
These keys need to describe information about the object in a standard way. For example, the key InProcServer32 should have a value
associated with it that is the name and location of the dll containing the component. The value of the CLSID key usually has a user-friendly
name to refer to it. The InprocServer32 key belongs under the CLSID key of your component. This information is the least that you can use in
the registry and still be functional. Optionally, you can create program ID (progID) keys to look up CLSID in an easier and much clearer
method. You can get the name of the CLSID by looking under the value of a progID, and vice versa. Often times you want to add more
information, such as program IDs, version independent program Ids, and keys to look up CLSID from progIDs. Refer to Illustration 1 for a
clearer picture of this.
Exam Watch: A CLSID takes the form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}. This isnt very user friendly, or
programmer friendly for that matter. When you go to register this under the CLSID key you give it a human-readable value.
Illustration 1:
The Windows API functions you can use to manipulate the registry are listed as follows.
RegCloseKeyCloses a key
RegCreateKeyExCreates a key for the Registry
RegDeleteKeyDeletes a key
RegDeleteValueDeletes the value associated with the key
RegEnumKeyExEnumerates the subkeys
RegEnumValueEnumerates the values
RegOpenKeyExOpens a key
RegQueryInfoKeyReturns information about a key
RegQueryValueExReturns the value of a key
RegSetValueExSets the value for a key
Using these functions and knowing where to place items in the registry will help you keep your programs information and dependencies
organized.
Packaging and Distributing an Application
When you are ready to package and distribute an application, you have many different alleys that you can go down. Packaging can range from
placing zipped files onto a floppy disk or to an elaborate setup program on a compact disc. How you distribute your application is related to
how you package it. Packaging and distributing an application is also impacted largely by who the target audience is.
Using .cab Files
A .cab file is a cabinet file. A cabinet file is convenient in a couple of ways. Cabinet files compress the files that they contain and use an
efficient non-file-specific compression algorithm. Additionally, by packing many files into a .cab file you reduce the total file count.
Cabinet files are also useful for file security. Using signed .cab files to distribute your controls or libraries, you assure the user that the file was
not modified since it came from you, the manufacturer. This file contains your original control as well as information about the file, such as
when it was created and how to install it.
Creating a .Cab file
A couple options that you have to create a .cab file are CABarc and MakeCAB. Here I will focus on the use of MakeCAB. MakeCAB was
created for use in making setup programs. Here a standard format is used. You will have a Setup.exe file on the first disk as well as a
setup.inf, more on this later, and an appname.1 file. Each successive disk will have an appname.n file where appname is your application
name and n is the count. MakeCAB creates the setup.inf file to guide the setup program through the appropriate appname.n files when they
are needed. To create this disk layout, a Diamond Directives file (.DDF) is needed for use with MakeCAB. This file lists all the files your
install program needs as well as some optional parameters. The four optional parameters are as follows:
Capacity size of the target disks
How the cabinet files will be named
The visible labels of the disks
The tolerable random access level
Here is a sample of a .DDF file. In this file, we will take a hypothetical application called whirry.exe and place it into cabinets.
Exercise 10-2 Creating a Cabinet File
1. Create your .DDF. Here is a sample from which you can base yours.
; SAMPLE DDF File
; a semi-colon comments a line
.Set DiskLabel1=Setup ; Labelling disks
.Set DiskLabel2=CABFiles
.Set CabinetNameTemplate=Whirry.* ; Sets Name Whirry.1 .2 .3
.Set MaxDiskSize=1.44M ;Standard floppy disk size
;First Disk setup files should not be compressed
.Set Cabinet=off
.Set Compress=off
.Set InfAttr=
files\setup.exe
files\setup.inf
; Compress the rest of the files
.Set Cabinet=on
.Set Compress=on
files\whirry.exe
files\whirry.hlp
files\share\MFC42.dll
;continue listing files
2. Now that you have made your .DDF, you can turn this into disk layout by using the following on a command prompt:
MakeCAB /f whirry.ddf
Exam Watch: A .DDF is useful in creating cabinet files, with maximum control of where files are located and how well they are ordered
according to the install.
This created the layout, and the file setup.rpt is placed in the current directory telling what the program did. MakeCAB will also create
directories based on size for each disk and files. Setup.inf is created as well with information on the files and where they were placed.
Using Signed Cabinet Files
As we said earlier, a signed .cab file assures a user that a file has not been modified since it came from the manufacturer. It is basically a way
to shrink-wrap a component ensuring that it hasnt been tampered. By tampered I mean a malicious user hasnt added any unexpected extra
actions to it.
You will need to obtain a software publisher certificate (SPC) if you intend on releasing a signed cabinet file. Now to practice this is not a step
you should have to take, so Visual Studio comes with a utility to make a test certificate. This is located in the CAB&SIGN directory of your
CD-ROM.
Exercise 10-3 Signing a Cabinet File
1. Launch SignCode from the CAB&SIGN directory. This starts the wizard for signing a cabinet file.
2. Click next on the welcome screen. Figure 10-12 is how I filled it in. Fill yours in and click next.
Figure 12: The Code Signing Wizard enables you to sign your cabinet file
3. On this page, you should type the name of the Software Publisher Certificate in the first dialog; this is an .spc file. In the next dialog you
sign it with your private key, so enter the name of a private key file (.pvk).
4. Click next twice and click Sign to sign your file.
That does it. Now your .cab file is signed. You can sign your .dlls and .ocx files as well. The benefits of signing a cabinet file are that you get
compression and you can pack your .inf file with it. Additionally, you can embed a signed .cab onto a web page.
Planning Application Distribution
Now you have the application all programmed, debugged, tested, and packaged. Your next step is choosing how you would like to distribute
the application. Your choices range from hard physical objects to network installation mediums. These mediums range further in possibilities.
For instance when using a physical object, it could be floppy disk, or in most cases, a bundle of floppy disks, or CD-ROMs. And when you
use a network distribution type, your choices range from an internal server to a web-based distribution.
InstallShield has the Media Build Wizard to help you get your package onto your desired medium. This allows you to create folders suitable
for most types of distribution mediums. You can also specify languages and operating systems here. We will take a look at these types of
distributions in the following sections.
Floppy Disk-Based Distribution
Though you rarely see floppy disk-based distribution anymore, there are still some uses for it. In a small corporate environment a single
floppy disk may be used to distribute the application amongst users. A floppy disk is also very inexpensive and can even fit in your shirt
pocket!
Exercise 10-4 Building a Floppy Distribution with the Media Build Wizard
1. First click Build | Media Build Wizard; this will get you started with the wizard.
2. Choose a name for the Media Name field. I chose MyMedia. Click Next and you will be presented with the dialog box from Figure
10-13.
Figure 13: Select the disk type for distribution
3. Choose a 3.5 Diskette 1.44 Mbytes in this dialog. Click Next.
4. Choose Full Build and click Next.
5. You can verify your company name, application name, and version here in this dialog box. For the product category, I chose Personnel.
You can ignore the Misc field and click Next.
6. The platforms you chose earlier should appear in this dialog. You can change them or leave them as is and click Next.
7. The summary dialog box appears letting you review your choices before starting the build process. You can click Finish here to create
the image.
8. A message will appear and let you know when the build was successfully created. After clicking Finish, you will see the log of the build
in the Build tab.
Compact Disc-Based Distribution
Because most users with a computer have a CD-ROM drive nowadays and also because of the large storage capacity, the CD is the most
common distribution platform for a consumer market. Most users of the Windows platform have a version that supports autorun. This feature
helps automate the installation process. You can have the autorun automatically run setup if the file is not already installed as soon as the CD
is read into the CD-ROM drive. You should have a CD-ROM recorder to make a CD for CD-based distribution. For a micro distribution you
can create all the CDs yourself, but for a larger scale you would want to ship a CD off to a duplication company. To create a CD project in the
InstallShield Media Build Wizard, you can specify CD instead of floppy disk and the remaining steps are similar.
Web-Based Distribution
To distribute an application on the web, there are security issues you have to consider. Th first is having a web presence and access rights to
the server. Next, you need an administrator who can set up the server to allow access for your users and block those people whom you dont
wish to use this program. You may be releasing a beta product on the web for private testing. Therefore, you dont want anyone to access a
nonexpiring version of your software and you should set up access levels. If this were an internal company software product and you would
like to distribute using the web, obviously you dont want most of the world to see this and download it.
If you are releasing software as shareware then web-based distribution can be seen as a must-do. This is the best way to target many millions
of potential users. There are many repositories out on the web that deal mainly in archiving and distributing software. You may recall that
popular games, such as Doom, were released first as shareware, thus exposing them to many millions of users. Utilities that you may know,
like WinZip, still are released as shareware. This benefits both the user as well as the company. The user is now able to try software out before
they decide to purchase it. The company has a low-cost distribution vehicle and can have many people demo (or bug test) an application,
which in turn increases probability of purchases.
Network-Based Distribution
Network distribution has very little differences from CD-ROM-based distribution. As a matter of fact, sometimes when an application is
site-licensed, they will place the disks in a network CD-ROM server. When you are creating an application for network distribution, you
choose the same options in the Media Types dialog as for a CD-ROM project. Also, if you are behind a firewall it is much easier to keep the
large population as a whole from trying to access the files. Your network administrator can also set up permissions allowing the appropriate
people access to the files.
Using Microsoft Systems Management Server to Distribute an Application
Microsoft Systems Management Server (SMS) is a great means for distributing an application in a large corporate setting with a strong
Information Technology (IT) department. With this tool you can automate the process of distributing the application. This tool can check a
clients current configuration and help plan on how to deploy the application to their machine. You can think of four basic components that
Systems Management Server will use in organizing a solution. These are in the following bulleted list.
PackagesYou can think of these packages as a basic unit of software distribution. The Systems Management Server makes it possible to
work with these packages. A package contains all the information that makes up a distribution. Some of this information includes schedules,
configurations, file lists, and preferences.
ProgramsA program must be contained in a package. These programs manage the installation on the client side as well as any other
command-line work you would like to do. A package can have several programs.
Package Source FilesThese files execute the programs within packages.
Distribution FolderThis is where package source files are placed on distribution points. These points are shares on network drives
where the package source files get copied to so clients may access them.
There are two ways to create a package. One way is by using the Site Server with the SMS administrator console. You can also obtain a
package definition file (.PDF) and use a wizard to help you along the creation process. Once this package is created it is pushed to the
appropriate machines. Pushed is another way to say the package is placed on the clients machine without their interaction. The server doesnt
push the package in a direct manner, it gets sent using two gateways. These gateways are the client access point (CAP) and the distribution
point.
The packages are first copied onto the distribution points. Then an advertisement of the package is created and copied to the client access
point. The advertisement contains information about the package; the programs it contains, and the schedule of when it will be available and
which machines should receive it. At some point the clients will query the client access points and see if this advertisement targets their
machine. If it does, they proceed to call the distribution point to get the program and files with which the package associated them.
Prior to running through these steps, the Advertised Programs Client Agent has to be installed on each client in the targeted machines. This
program enables the software distribution on the client machine. Every communication involved in connecting the client to the client access
point and the distribution point is made by the advertised programs client agent. This process gets the application pushed onto the clients
machine.
Systems Management Server Tools
The Create Package utility is found in the Definition Wizard and the Distribute Software Wizard. Systems Management Server uses these to
execute the distribution process of an application or even an operating system. These are the tools you use to distribute the application in the
manner mentioned earlier.
Using the Systems Management Server Installer, you can create the package definition file, script, and the compressed executable that is
placed onto distribution points, the client access points, and eventually the clients. Systems Management Server Installer creates the .PDF in
self-extracting compressed files. This is handy, so that additional commands arent necessary. These files then are added to a package and
these packages are advertised to the clients. With the Systems Management Server Script Editor, you can modify the files to further customize
the deployment of your application.
The Distribute Software Wizard will take you through each step of the process to automate the deployment of your application over the
Systems Management Server. You can automate these using the console tool to create packages, programs, collections, and advertisements for
the packages. Create package is also present in the Distribute Software Wizard in the same way it lies in the Definition Wizard. This allows
you to perform a wealth of functions. You can specify a package to distribute. After you specify a package to distribute it will be shown, along
with your past packages, in the Systems Management Server Site database. Using this tool, you may choose which packages to prepare and
distribute. You can also choose, from entries in a list, where the packages distribution point will be. These are listed in the Systems
Management Server with the name, site, and type attributes. This tool lets you advertise a program too. You can customize the advertisement
of the package. Furthermore, you can advertise specific programs to certain collections.
Accessing Client Access Points and Distribution Points
For a targeted machine to be updated, at least one client access point and one distribution point must be available on the network. The purpose
of the client access point is to maintain a communication link between the client and the server. The purpose of the distribution point, as you
may guess, will store package information for distribution. Prior to distribution, both the client access points and the distribution points should
be checked and adjusted to fit the needs of the current distribution. Sometimes, a primary site may be used as both the client access point and
the distribution point, or other computers may take these roleseven multiple computers can do each task.
A collection is required for each advertisement and subcollections can qualify as the collection required for an advertisement. Systems
Management Server provides you with multiple collections to use. with these you can better model a personalized setting for use with your
current solution. These collections can be expanded and retracted. When a client is removed or added to a site, the Systems Management
Server must evaluate the collection. Usually, the administrator schedules these evaluations based on specific timeframes. This assures the
administrators that the collections are current when deploying an application.
You can create packages manually with the Microsoft Systems Management Server console, or you can automate the process using the
Distribution Wizard. To perform either process the steps are largely the same. To create a package, you create a package source directory and
figure out what the package properties will be and apply them. A Systems Management Server package is packed with all the files needed and
all the commands needed to act on those files, along with other information such as which distribution points are available to provide the
package source files to all the client machines. A package can contain many .exes, .dlls, help files, and .inf files that allow complex
configuration options. The package doesnt have to contain all these types of files because it is very scalable.
You need to determine certain properties for each of your packages. The following list describes the properties that should be determined. To
configure these, you use the Create Package in the Systems Management Server console or from the definition wizard.
Package IdentificationGeneral information is used here, such as file name, version, language, and publisher. This pretty much mirrors
what you see when you right-click a file in Windows Explorer.
Definition Files are PresentAs you know, the package definition file is a plain text file used to make the Systems Management Server
packages. It contains the command line text that should be executed as well as other parameters of the package. The command line adds
versatility to the process; an example is that you can have an automatic or an automated install. Systems Management Server uses all this
information to perform an automated installation when configured as such.
Set up the Package Source DirectoryYou must create the package source directory for the package source files so they are available to
a Systems Management Server service account. The package source directory ranges from anything you typically perceive as a drive, such as
a local hard drive, a CD-ROM drive, or even a network drive.
Choose CompressionYou can figure whether or not a Systems Management Server will create and store a compressed copy of the
package source files. When the Systems Management Server sends off the package to its distribution points in other Systems Management
Server sites it will send along a compressed copy of the package files.
Determine StorageUse the data access tab to choose whether to access this distribution folder through the common Systems
Management Server package common share or to set up a private personal share name for this package.
Determine Update PeriodThis Data Source tab may be used to determine and configure an update schedule for all of your distribution
points. This is very useful when you would like updates to occur to different client machines at different times.
Creating a ScriptWhen a program is distributed that needs user input, a script is necessary to perform the inputs. You can create this
script with the Systems Management Server Installer. Using scripts to perform these installations is great, because all the work can be
performed in off-hours, this way reducing vital network bandwidth during working hours.
Using Programs
One program is required for each software distribution package, and multiple are possible. These programs are sets of commands that are
created and then run on clients when the package is made. Practically any action can be taken and assigned to a program. These programs can
be made to run batch files, replace drivers, distribute data files, or even install an operating system on the client.
In the Systems Management Server administrator console, an administrator can identify the program, set up requirements for the programs, set
up the environment for the program, and specify more criteria for this program.
To install a distributed application, the client must be able to access at least one distribution point on the Systems Management Server site.
After Systems Management Server has defined these distribution points, it will use the schedule provided by the administrator to decide when
to copy the package to the distribution point. If the targeted client machines are running different network operating systems then the package
must have all network access to the client machines. When working across domains, a trust relationship between them should be set up so the
targeted client machines will be able to be updated regardless of their network operating system or their domain.
Systems Management Server makes sure a distribution point has all the information needed to respond to an advertisement that a client will
receive. If the package source files that the advertisement refers to are not currently on the distribution point, your Systems Management
Server sends its compressed package to this distribution point.
When the program in the package is ready to be distributed to the clients you advertise the package to the target machines. In this
advertisement you must include the following: the package and program which will be run on the client, the target machines, the schedule for
the advertisement to the client machines, and when the program should be assigned. Collections are used to specify which target machines
will receive the advertisement for a program. If a client machine logs on and is targeted by the settings in the advertisement, one of the
following occurs.
Systems Management Server lets the user know a program is available and leaves it up to this user to decide whether to install it and
when to install it.
Systems Management Server lets the user know a program is available and if the user doesnt run this program by a specified time,
Systems Management Server will automatically run it. This leaves a few options up to the user. They can run the program immediately, run it
at a later time, or let it automatically run at the specified time.
Systems Management Server doesnt alert the user and runs the program at a specified time or event.
The actual act of running one of these programs involves the client connecting to a distribution point with the Advertised Program
Manager Component that was specified in the advertised package.
To create an advertisement you have two choices. One choice is to use the Distribution Software Wizard. The other choice is to use the
Systems Management Server console. Using this console you can create an advertisement from any existing collection, package, or program.
Exercise 10-5 Creating an Advertisement
1. Right-click Advertisements and choose new. An Advertisement Properties dialog box will appear.
2. On the General tab, you must enter values for the following fields: Name, Package, Program, and Collection. If you have defined
security access measures be sure that the target clients have an account to access the package.
3. You may set up the advertisement start time, which is optional. You can set this up by clicking the schedule tab and setting the date and
time. This will specify when the client may start to run the package.
4. You may also set an optional expiration time. To do this you select the advertisement will expire box on the schedule tab. By making it
expire, it means that it doesnt appear on the Advertised Programs Wizard or monitor. It does not delete the program from the distribution
point.
5. An advertisement priority may also be set here. It is optional as well. When you set a priority it is carried on to the child sites.
That sums up the use of Systems Management Server to deploy an application. This is a great service when you have a large organization and
a smaller IT department. The IT department can configure all of the client machines on a network within a scheduled period. This is powerful
as opposed to having all the users perform their own upgrades, especially if the users arent skilled in the area of software installations.
Installing and Uninstalling an Application
Believe it or not, sometimes an application needs to be uninstalled. Why, you may ask. the user may need to recover disk space or need to
move the application to another machine. A windows logo-compliant application must have an uninstall program, and it is generally a good
idea even if it is an internal corporate tool. Among the things that should be removed when you uninstall an application are the registry
entries, the start menu items, a desktop shortcut, the executable files, the private dlls, and the unused shared dlls. Things that should not be
removed are the users data files created with the program; shared dlls, for which it cannot be determined if they are still being used by other
applications; and data directories.
Your application should come with a graphical setup program that must be named setup.exe. When you choose the Add/Remove programs tab
in control panel, this is the program that windows will run to setup your application. Your application needs to add entries to the registry so
that the add/remove programs tab will have the definitions necessary to uninstall your application.
The application should follow these guidelines.
A window displaying the progress of the uninstall process should be provided. This is the means to get interactive uninstallation options
from users, such as prompting them if they would like to remove certain files. An option can be provided to perform a Behind the scenes
uninstall. This presents no information to the user and will just remove the application without any interactivity.
Be sure to describe in basic terms any errors encountered when uninstalling the application.
When you uninstall a program you decrement the usage count of a .dll that keeps track of whether it will be used after your program is gone.
When the count reaches zero you should prompt the user before uninstalling the .dll and give them the standard warning that it may still be
used. Be sure to add entries to the uninstall registry key so that a user may uninstall the program directly from the control panel add/remove
programs dialog.
Creating a Setup Program
Your InstallShield comes with an uninstall program called unInstallShield. This program can record events during setup and keep track of
these changes. This way you can have a more thorough uninstallation of your application.
When you use this program to uninstall a program, a dialog box will pop up and place check marks next to each component that it
successfully uninstalls. After this uninstall finishes, it will give a summary to the user and if any parts could not be removed it will inform
them in this box. You can now click the details button to see further information. An edit control is used, enabling you to copy this
information to the clipboard.
To test your uninstall you should install the program, run it once, and uninstall it with the uninstallshield program. If you use the setup.rul file
that InstallShield creates for you, after completing the wizard your application will automatically be uninstallable under Windows 95/98 and
Windows NT 4.0. InstallShield takes care of all the things you need to do to uninstall an application. InstallShield will enter the required
information into the registry so entries will appear in the control panels add/remove programs dialog. It will also keep a log file of which files
were set up on the users computer. Lastly, it will copy an uninstall program into the program directory of the application and information for
the uninstallation into the file uninst.isu.
UnInstallShield can uninstall some files, and some it cannot. Let me describe those files that can be uninstalled. Read-only files can be
removed. Files generated by Windows help engines can be removed. These files have the following extensions: .gid, .ftg, and .fts. Any folders
that are created by the install and empty after the uninstall has removed the files will be removed. It will also make changes to .ini, .bat, and
.sys files, if applicable.
The files that cannot be removed are any files with the hidden or system attributes. Also, files the user has created will not be removed.
Folders that contain files will remain behind as well.
Using Zero Administration for Windows (ZAW) to Distribute an Application
The Zero Administration Initiative for Windows is a new strategy developed by Microsoft to reduce the total cost of ownership when setting
up and maintaining employees machines. Applications will no longer need to be machine specific. This is useful in case an employees
machine goes down. rather than setting up an image and reinstalling all applications, you may just have the user go to a different computer
and log on. All of his applications, documents, and settings will be there waiting for him. This reduces downtime losses in productivity.
The Zero Administration Initiative makes this all possible. In using this, an administrator will only need to administrate a centralized machine.
This helps avoid many costs associated with administrating users machines. Whereas computers slowly moved from distributed computing to
more individual computing, there is this push back to distributed computing and Zero Administration can be combined with some of these
strategies. Some key points of the Zero Administration Initiative are in the following list.
Disallow unauthorized software installs
Manage on a per-user basis which files and software they can access
Centralized management of all the machines and system-wide lockdowns
System lock downs to prevent unauthorized operations
I will touch on each of these points here. Disallowing software installs is useful when you have users who are not very knowledgeable about
computers and could cause conflicts. Managing which software and hardware resources a user is allowed to use has a couple of purposes. One
is that they are presented less options, which will reduce confusion for a computer intimidated user. Another purpose is they wont be able to
get at their system files and lose functionality by overwriting or modifying them. System lockdowns also allow the administration to have PCs
with the exact same configurations, allowing easy resolution of problems on all machines.
Systems Management Server coupled with Zero Administration provides a great control and cost-effective solution for administering
workgroups. Coupling these together, a software package can be deployed on the machines with a great control and make upgrades work
seamlessly. It also provides software and hardware inventory as well as remote control over the PC for network monitoring or remote
administrating. the zero Administration Kit keeps the state of operations of the machines whereas the Systems Management Server schedules
and upgrades along with distributing and inventorying the machines.
InstallShield is packaged with Microsofts Visual C++ to aid in creating Microsoft Windows logo compliant installation and uninstallation
programs. A log file is generated automatically with the setup program for you. This log file is used to uninstall the application according to
Microsofts guidelines. Without this tool, in the past creating setup programs was not a trivial task, or they didnt appear very user friendly.
Also, uninstallation was practically nonexistent, which was a shame because it is a very useful feature. COM components also must be
registered in order to use them, so the logical place to do the registration is during setup time. These can be set up with minimum effort if your
dll supports the DllRegisterServer and DllUnregisterServer functions, so that they may automatically register. Cabinet files are a convenient
way to package and distribute files. They pack many files into one or more easy-to-manage files. Rather than distributing 86 files with a setup
program, cabinet files let you manage a smaller number of files. Cabinet files can also be signed, meaning they are guaranteed unchanged
since the source distributed them.
New technologies from Microsoft make setting up users on machines a less costly and time consuming event. With the Microsoft Systems
Management Server you can schedule software and operating system upgrades and require them to occur. You can also give the user the
option to receive this push, schedule it for later, or not perform it. With Zero Administration Kit you can make users not system dependant;
that is, they wont need to be on a specific machine in case it goes down or is unavailable at the time. This way you can also prevent costly
user mistakes related to misconfiguring their machine, such as unauthorized software installs and changing system files. These are valuable
concepts and tools for reducing the IT departments expenditures and lost productivity.
Two-Minute Drill
The first thing a user will see when receiving your application is the installation program.
Microsoft provides a version of the popular Installshield program with most versions of their Visual C++ compiler.
Your installation will depend largely on the environment your application is being used in and who the people are that will be using it.
A good way to check which files your program is dependant on is to use Quickview.
Network installations are increasingly more common in the workplace. If you are programming a database application, it is almost
necessary to give your users a network installation option.
File components are where files are grouped together in a logical order for installs.
COM components need to be registered whether they are controls, containers, or servers.
InstallShield provides a very simple means to register your components upon installation.
Packaging can range from placing zipped files onto a floppy disk or to an elaborate setup program on a compact disc.
A .cab file is a cabinet file. Cabinet files compress the files that they contain and use an efficient non-file-specific compression
algorithm.
InstallShield has the Media Build Wizard to help you get your package onto your desired medium. This allows you to create folders
suitable for most types of distribution mediums.
Microsoft Systems Management Server (SMS) is a great means for distributing an application in a large corporate setting with a strong
Information Technology (IT) department.
The server doesnt push the package in a direct manner, it gets sent using two gateways. These gateways are the client access point
(CAP) and the distribution point.
The Create Package utility is found in the Definition Wizard and the Distribute Software Wizard.
For a targeted machine to be updated, at least one client access point and one distribution point must be available on the network.
In the Systems Management Server administrator console, an administrator can identify the program, set up requirements for the
programs, set up the environment for the program, and specify more criteria for this program.
A windows logo-compliant application must have an uninstall program, and it is generally a good idea even if it is an internal corporate
tool.
Your InstallShield comes with an uninstall program called unInstallShield. This program can record events during setup and keep track
of these changes.
The files that UnInstallShield cannot remove are any files with the hidden or system attributes.
The Zero Administration Initiative for Windows is a new strategy developed by Microsoft to reduce the total cost of ownership when
setting up and maintaining employees machines.
the zero Administration Kit keeps the state of operations of the machines whereas the Systems Management Server schedules and
upgrades along with distributing and inventorying the machines.

Chapter 11: Maintaining and Supporting an Application
Logic Errors. 2
Syntax Errors. 3
Run-time Errors. 6
Two-Minute Drill 46
Fixing Errors
Prevent Future Errors
Distributing Application Updates
Errors are a fact of life for programmers. Even the best-designed programs will have some errors that have to be fixed. Sometimes errors can
take longer to fix than it took to write the original code that you are fixing. This is why testing is a very important part of the development
process. Depending on the complexity of your program, errors might not even appear until long after your program has been released. If an
error is fixed after your program has been released, then you will need to create an update. It has become a common occurrence to release
updates to an application. Microsoft routinely releases service packs to update its products. Updates can fix errors as well as make changes to
business rules.
In this chapter, we will discuss some common errors and how to fix them, how to prevent future errors, and how to distribute an update to
your application. These concepts are applicable to the exam as well as on the job.
Fixing Errors
There are three basic types of errors in programming: logic, syntax, and run-time. Each type of error has to be dealt with differently and you
need to understand the differences among them.
Logic Errors
Logic errors are the cause when the results of your program are not what you expected. This situation is commonly referred to as a bug in the
code. The application will compile and run without any problems, but the code does not perform the expected task. For example, lets say you
are trying to delete customers from a database who have not placed an order in one year, but instead, your application deletes all of the
customers who have placed an order from you in the past year. This would definitely cause some problems. The code didnt cause your
application to generate a run-time error, but it is a more critical error as far as the people using your application are concerned.
So, how do we find logic errors? You can find some through code reviews and walkthroughs, but the best way is to test your program. We
discussed the different types of testing and debugging techniques in Chapter 9. You should perform unit testing before integrating the unit
with other modules. Then your application should go through beta testing. This allows independent testing of your application. As errors are
found, you can use the debugging techniques discussed in Chapter 9 to assist you in determining where the error is. Breakpoints, the TRACE
macro, and assertions can help you see intermediate values. Breakpoints allow you to pause program execution at the lines of code that you
suspect contain errors and then walk through the code and view data and conditions at intermediate steps. The TRACE macro will write
information that you specify to the debug window. You can use assertions to find logical errors in your code. Assertions are not error
handlers, but a debugging tool to check expressions. For example, in the following code, a function returns a value. If the function returns a
negative number, it wouldnt cause an error, however, if your logic didnt expect negative values, your results could be inconsistent. By using
the ASSERT macro, you can check for logic errors.
int x = ReturnValueFunction(y);
ASSERT(x >= 0);
Syntax Errors
Syntax errors are the result of using the programming language incorrectly. You might have forgotten a bracket, misspelled a keyword or
variable, or didnt include the correct parameters in a function call. There are many different ways to create syntax errors. When you compile
your program, you will receive compile errors telling you the line of code on which the error occurred. Of course, this isnt necessarily the
actual line where the error occurred, just where the compiler found an error. You will have to find these errors and fix them in order to
compile your program.
Visual C++ 6.0 offers some features to help you prevent syntax errors. These options can be selected by clicking the Tools menu and then
clicking Options. Click the Editor tab to see the Options dialog box, as shown in Figure 11-1.
Figure 1: Choose syntax features from the Options dialog box
The Auto List Members option will display a list of methods and properties when you type a period (.) or an arrow (->) after a valid variable
that is a structure or an object. You can select the desired method or property and not have to worry about spelling errors because it will insert
the name of the method or property for you. In Figure 11-2 we are using a structure that contains service status information. When we type the
variable name for that structure, m_status, and then type . (period), we get a list of the contents of that structure. You no longer have to go
and look it up in the header file or in help.
Figure 2: Use the Auto List Members option to display a list of members and properties
Auto Type Info allows you to view type information for a variable by placing the pointer over it. Using the m_status structure variable in
Figure 11-3, you can see that by placing the pointer over the variable we get information about the variable, including the type of variable and
the class that it belongs to.
Figure 3: Use the Auto Type Info option to view a variables type information
Auto Parameter Info will display the parameters required for a function. This will assist you in determining which parameters are needed as
well as the parameter data types and return data type. Using a class variable, in Figure 11-4, you can see that when the ( is typed, we get the
information for the method. It displays the return type as well as the parameters and their types for the method.
Figure 4: Use the Auto Parameter Info option to display the parameters that are required for a function
Syntax coloring uses different colors for various code elements, such as keywords or comments. This can give you some visual representation
of your code. You can even define some custom keywords that you would like to have in color, and what color you want them. In Figure 11-5,
the keywords else, while, if, and breakwould be a different color than the code, and the comments would be another color.
Figure 5: Syntax Coloring gives you a visual representation of the various elements in your code
Run-time Errors
Run-time errors are errors that occur while the application is running. These can be errors that occur due to an invalid action (using a pointer
that you havent allocated memory for), invalid data (dividing by a variable with a value of zero), or system conditions that prevent an action
from occurring (out of memory or out of disk space). There are different methods for fixing run-time errors. Which method you use depends
on what kind of error you are fixing.
Another use of assertion statements is to test for error conditions. Assertion statements should not be used to replace error-handling code. You
should use assertion statements to check for errors in your code where errors should have been handled by the preceding code. In the
following example, a function returns zero if it succeeds and returns a negative number to indicate an error code if an error occurs. What if the
function returned a positive number? The error-checking code does not account for a positive number. Using the ASSERT macro, you can
check to see if that is a condition that is occurring. If the function returns a positive value, then the Assertion dialog box will appear. You
should use assertions anywhere in your program that an assumption is being made. As an example, use an assertion anywhere that you rely on
the data being in certain range of values or non-NULL.
res = myFunction(x);
/* Code to handle errors */
if (res < 0)
{
/*handle error*/
}
ASSERT(res <= 0);
You can also use breakpoints to assist in finding errors. Place breakpoints in the code that you suspect and then step through the code to find
where an unexpected result is located. The Watch window or Quick Watch can be used to view variable and expression values. These
techniques were discussed in more detail in Chapter 9.
Prevent Future Errors
To prevent errors from happening after you distribute your application, you need to implement error trapping and handling. This will require
you to write good error checking that anticipates problems or conditions that are not under the control of your application and that will cause
your program to execute incorrectly at run time. This should be accomplished largely during the planning and design phase of your
application. It requires a thorough understanding of how your application should work and the anomalies that can pop up at run time.
For run-time errors that occur because of conditions that are beyond a programs control, you should use exception handling and check for
common problems before executing an action. An example of checking for errors would be to make sure there is a floppy disk in the drive
before trying to write to it or make sure a file is there before trying to read from it. An example of when to use exception handling would be
retrieving a recordset from a database. You might have a valid connection, but something might have happened after your connection to cause
the retrieval of a recordset to fail. You could use exception handling to trap this error rather than having a cryptic message appear and then
having to quit your application.
Exceptions should be used to prevent your application from quitting. We will cover the exception handling that is provided by the C++
programming language and the Microsoft Foundation Class Library (MFC). They provide support for handling run-time errors, called
exceptions, which can occur when your program is running. Using exception handling, your program can take steps to recover from abnormal
events outside your programs control rather than crashing your application. These exceptions are handled by code that is not run during
normal execution. Exceptions can be handled by throwing and catching exceptions. When an exception is raised, it is called throwing it.
When you create an exception handler, it will then catch the exception.
To enable the C++ programming language exception handling, click the Project menu and then select Settings to bring up the Project Settings
dialog box. Go to the C/C++ tab and select C++ Language in the Category box, as seen in Figure 11-6, or you can use the /GX compiler
option.
Figure 6: Enable C++ exception handling from the Project Settings dialog box
Now that we have enabled exception handling, lets look at how to implement it using the C++ programming language. You use the try, catch,
and throw keywords for exception handling. The syntax is as follows:
try-block :
try {
code to handle exceptions for
(code that is vulnerable to throwing exceptions)
}
catch-block :
catch ( exception-declaration )
{
code to handle the exception
}
throw-expression :
throw assignment-expression
opt
The try keyword basically turns the exception handler on. This is code that you believe is susceptible to errors and could cause an exception.
The compound statement following the try keyword is the guarded section of code. If an exception occurs inside the guarded code, it will
throw an exception that can then be caught, allowing your code to handle it appropriately. The catch keyword allows you to handle the
exception. You can use multiple catch blocks to handle specific exceptions by placing an argument in the exception-declaration statement
which indicates the type of exception the clause handles. The type can be any valid data type, including a C++ class. You can use an ellipsis
() as the exception-declaration, which will catch all exceptions.
Exam Watch: The catch handlers are examined in order of their appearance following the try block. This is important to remember for the
exam. If the first catch uses the ellipsis, it will always catch the exception, and any handlers after it will never be used.
The throw keyword raises the exception. The assignment-expression can be any valid data type, including a C++ class. If the
assignment-expression is blank, it throws the current exception. In the following code, we are calling the function SomeFunction. Inside
SomeFunction if the variable x equals zero, then an exception is thrown with a value of 10. If the variable x is a negative number, then it raises
an exception with a string to identify the exception.
void SomeFunction(int x)
{
if (x == 0)
throw (10); //throw a specific error code
if (x < 0)
throw ("Negative Number");//throw an error string
}
main(){
int x;
try {
SomeFunction(x);
}
catch(int& I){
//An integer is caught
}
catch(){
//catch anything that can be thrown. Any primitive type and object
}
}
You can also implement exception handling using the MFC exception macros. Microsoft recommends using the exception handling supported
by the C++ language. It is recommended to convert existing code using the MFC exception macros to the C++ language exception handling.
Converting to C++ exception handling results in smaller executables and it has more flexibility in the types of exceptions that can be handled.
You do need to understand how the MFC macros work though.
The syntax for the MFC exception handling is a little more extensive than the C++ language, but it is similar to the C++ exceptions. The
syntax for the MFC exception handling is as follows.
Try Block:
TRY
{
}
Catch Blocks:
CATCH (exception class, exception object pointer name)
{
code to handle an exception
}
AND_CATCH(exception-declaration)
{
code to handle another exception
}
END_CATCH
or
Try Block:
TRY
{
}
Catch Block:
CATCH_ALL(exception object pointer name)
{
code to handle all other exceptions
}
END_CATCH_ALL
or
Try Block:
TRY
{
}
Catch Blocks:
CATCH (exception class, exception object pointer name)
{
code to handle an exception
}
AND_CATCH(exception-declaration)
{
code to handle another exception
}
AND_CATCH_ALL(exception object pointer name)
{
code to handle all other exceptions
}
END_CATCH_ALL
Throw statements:
THROW(exception object pointer)
THROW_LAST()
Notice the exception handler is terminated with the END_CATCH_ALL macro. If there wasnt a CATCH_ALL or an AND_CATCH_ALL
macro, then the exception handler would end with the macro END_CATCH. Also, if the only catch block is a catch all type, the syntax
would be CATCH_ALL instead of AND_CATCH_ALL. If there is more than one catch macro after the first catch macro, you add AND_ in
front of it. Also notice the syntax is a little different for the catch macro arguments. For the CATCH macros, you pass in two parameters, the
exception class type to catch and a name for the pointer to the exception object. The CATCH_ALL macros only have one parameter, the name
for the pointer to the exception object. The THROW macro throws a specified exception. The THROW_LAST macro re-throws the locally
created exception to an outer exception handler. Another difference is that you have to throw and catch CException objects or objects derived
from it. You cannot throw just any data type as you could in the C++ language. Lets look at an example. The following example attempts to
open a file using the CFile class that reads data from the file. If the file did not open correctly, then the CATCH block, using the
CFileException type, would handle the error. If any other exception types occurred then the AND_CATCH_ALL handler would handle them.
Of course, it would be better programming practice to check to see if the file is open before attempting to read from it and allow the user to
choose another file.
CFile f;
char* pFileName = "test.dat";
char buf[100];
TRY
{
f.Open( pFileName, CFile::modeWrite );
f.Read( buf, 99 );
}
CATCH(CFileException, e)
{
AfxMessageBox("Error opening file.");
f.Abort();
e->Delete();
}
AND_CATCH_ALL( e )
{
THROW_LAST();
}
END_CATCH_ALL
As stated earlier, a catch block in the C++ programming language can take an argument of just about any data type, but MFC exception
handlers can only handle exceptions from the CException class. MFC functions throw exceptions of the class CException, or classes derived
from it. You use a variable that is a pointer to a CException object so that you can see more information about the exception. The information
available depends on the exception class used. As an example, you can use the CFileException class to determine exceptions caused by file
I/O operations. The class has an m_cause member that can be used to determine the cause of a file I/O exception. See the following code for
an example. The example uses the classes enumerated types of fileNotFound as a possible value in the m_cause member. Notice the exception
is freed in the catch block. You must delete an exception object in a catch block whenever a catch block throws a new exception. If it
re-throws the same exception, do not delete it. You also need to delete an exception if the catch block returns to normal execution. Exceptions
are deleted using the Delete method of the exception class as shown in the following example.
try
{
//code for doing File operations
}
catch( CFileException* e)
{
if( e->m_cause == CFileException::fileNotFound )
AfxMessageBox(The file could not be found.);
e->Delete();
}
If you use the CATCH_ALL or the catch() handler, you can determine what type of exception occurred by using the IsKindOf method,
which takes an argument for a pointer to the class structure. You can use the RUNTIME_CLASS macro to return the class structure of a class
type. In the following example, instead of a CATCH statement looking for a CFileException type, we determine the exception type using the
IsKindOf method of the CException class.
try
{
//code for doing File operations
}
CATCH_ALL( e )
{
if ( e->IsKindOf(RUNTIME_CLASS( CFileException )))
{
f.Abort();
AfxMessageBox("Error opening file.");
}
else
AfxMessageBox("Other error.");
e->Delete;
}
There are some exception classes derived from the CException class that are provided by the MFC. To throw these specific exception types,
use the throw exception functions. Table 11-1 lists the classes and throw functions.
Exception Class Throw Function Use
CmemoryException AfxThrowMemoryException
out of memory conditions when using the
new operator
CFileException AfxThrowFileException file exceptions when using the Cfile class
CArchiveException AfxThrowArchiveException
serialization exceptions when using the
CArchive class
CNotSupportedException AfxThrowNotSupportedException
exception from request for unsupported
service
CResourceException AfxThrowResourceException
exception from a Windows resource request
that cannot be allocated or found
CDAOException AfxThrowDAOException
exceptions from a DAO class databases
operations
CDBException AfxThrowDBException
exceptions from an ODBC class databases
operations
COleException AfxThrowOleException exceptions from OLE operations
COleDispatchException AfxThrowOleDispatchException
exceptions from OLE operations that use the
Idispatch interface
CUserException AfxThrowUserException exceptions that are specific to an application
Table 1: MFC Exception Classes derived from the Cexception Class
Exception handlers can be nested. Nested exception handlers can be thought of like the call stack. When you return from an inner exception
handler, the executing code is now guarded by the handler that is next on the stack. If your handler throws an exception, it will be caught by
the next outer-level handler. A catch block can throw a different exception or re-throw the caught exception using the throw keyword with no
argument to let an outer-level exception handler handle the exception. If there isnt an exception handler to catch it, your program will quit.
Exceptions are also handled in a calling chain. If a function calls other functions, and one of the called functions has an exception without an
exception handler, it will be passed up the chain of functions.
The calling chain works as follows: if a procedure has an exception without a handler, it passes the exception up the calling chain to the
procedure that called it until it finds one that has an exception handler. For example, in Figure 11-7, the only exception handler is in proc1. If
proc1 calls proc2 which calls proc3, when an exception is thrown in proc3, it checks for an exception handler in proc3. When it doesnt find
one, it goes up the calling chain to proc2. When it doesnt find an exception handler there, it goes up the calling chain again to proc1. There is
an exception handler here, so the exception can then be handled by the catch blocks. If no exception handler is found, a message box is
displayed and the program ends. Also, if an exception occurs inside a catch block, the exception will be passed up the calling chain. Any code
in the handler that came after the exception would not be executed. This is also true if you use a throw statement to re-throw an exception.
Because exceptions can occur inside a catch block, be sure to keep exception handlers simple. Analyze the code for possible problem areas
and be sure to test it thoroughly. You could also call functions within the handler that contain exception handling that could provide exception
handling for your handler, but that isnt good practice. Take extra care when developing your exception handlers. Exercise 11-1 shows how
exception handlers work.
Figure 7: The exception calling chain is one way to handle exceptions
Exercise 11-1 Using Exception Handlers
int Func2(int x)
{
int res = 0;
try
{
res = 1 / x;
}
catch (...)
{
if (x == 0)
throw 1;
else
throw "Unknown Error";
}
return res;
}
int Func1(int x)
{
int res;
try
{
res = Func2(x);
}
catch (...)
{
throw;
}
return res;
}
5. Add the following code to the main function. When you type Func1( you will get the Auto Parameter Info as seen in Figure 11-7.
int x, y = 0;
try
{
x = 1 / Func1(y);
}
catch (int err)
{
if (err == 1)
x = 0;
else
x = -1;
}
catch (...)
{
x = -1;
}
return 0;
Figure 8: Use the Auto Parameter Info option to display the parameters that are required for a function
6. Right-click the lines of code in the Func1, Func2, and main functions in the try and catch blocks and select Insert/Remove Breakpoint
from the pop-up menu, or press F9. Notice the red button that appears next to the line. This will stop the application when it executes this line
of code. Also notice the coloring used. By default, the keywords, such as try, would be in blue. Add a comment to your code. By default, it
will be colored green.
8. When the debugger stops at the breakpoint in main where Func1 is called, notice it is inside a try block. Hold the mouse over the
variable y to verify that the value is zero.
9. From the Debug menu, select Go, or press F5. The debugger will stop at the breakpoint inside Func1 where Func2 is called. Hold the
mouse over the variable x to verify the value is zero.
10. Press F5. The debugger will stop at the breakpoint inside Func2 where one is divided by x. Hold the mouse over the variable x to verify
the value is zero.
11. Press F5. The debugger will stop at the breakpoint inside the catch block inside Func2 because the code attempted a division by zero.
Press F10 to step to the next line of code. You are now going to throw an exception with a value of one.
12. Press F5. The debugger will stop at the breakpoint inside the catch block inside Func1. The code is now in another exception handler. The
throw statement will throw the current exception, which is an integer value of one, to the next exception handler. If there had been a different
error, it would have thrown an exception with the string Unknown Error.
13. Press F5. The debugger will stop at the breakpoint inside the catch block inside main. The code is now in another exception handler.
Notice it stopped in the catch block that had the integer. Hold the mouse over the variable err to verify it is equal to one. Press F10 to step to
the next line of code. Here, x is set to zero. When execution resumes, the code following the catch blocks will execute.
14. Remove the try and catch blocks in the main function. It should now look like the following code.
int x, y = 0;
x = 1 / Func1(y);
return 0;
15. Remove all the breakpoints in the project. From the Build menu, select Set Active Configuration, verify that the Debug version is
selected, and click the OK button. Press F5 to run the program. A dialog box will pop-up notifying you that some files are out of date. Click
Yes to build them and then a message box similar to the one in Figure 11-9 will appear.
Figure 9: You could see this unhandled exception message in the Debug version
16. From the Build menu, select Set Active Configuration, choose the Release version and click the OK button.
17. From the Build menu, select execute Chap11_1.exe or press Ctrl-F5. A message box will appear. Click the Details button to see a
message box similar to the one in Figure 11-10. This is what users of the program would see. Make sure you handle exceptions rather than
your program displaying this message box.
Figure 10: If you handle exceptions, the users of your program wont see this dialog box
There are some situations where you can save yourself some coding time and decrease the code in an application. Look through your project
for code that is repeated. For example, there may be multiple places where you are opening a file. Consider creating a generic function that
can be used instead of writing the code where files are being opened. Then put exception handling within the function and have the function
return an error code for success or failure of opening the file. This also helps in preventing logic errors because you are not writing the code
over and over. You can test the function and then you dont have to worry about testing the code for each place in which you are opening a
file. This also makes your application smaller.
Another way to implement exception handling is to centralize exception handling. You can create a function that is called from all catch
blocks. The function would be called and then passed the exception. Inside the function, you would parse for different types of exceptions and
handle them appropriately. It is important to remember that this does not preclude you from adding exception handling in your functions. It
does minimize the exception handling code in each function.
Distributing Application Updates
Dont plan on releasing version 1.0 of your application and then thinking you are done. At some point in the future, you will more than likely
need to make an update to it. There are different reasons for needing updates. It might be that because the business rules for your application
have changed you are adding new features, or you might have customers who discover some bugs that werent found during testing. This is
common because you cant test for every possible computer hardware and software configuration. Whatever the reason, plan on the need for
updates.
When deploying updates, it is similar to deploying a full application, which was covered in Chapter 10. You will be placing your update on
some type of media for distribution such as CD-ROMs, floppy disks, or a web site for Internet or intranet downloads. We will be discussing
how to deploy an application update.
The first step to deploy your application is to package it. Files will be compressed and packaged into .CAB files. In an update, you dont
necessarily need to deploy all the files that were deployed in the full installation. You should only deploy the files that have changed. There
are several reasons for this. This will make your update smaller, which is more critical for floppy disk and web site deployment methods.
Another reason is that you can distribute the update freely without worrying about licensing issues because you are only deploying a small
(hopefully its small) subset of your application that cannot be run by itself. The files included in your update will overwrite the files already
on the customers computer. If you made changes to a database file, you have to be careful. You dont want to overwrite the existing database
with the new one that doesnt contain the data in the customers database. This would cause the customer to lose all of their data. If this is the
case, you will need to give the customer a way to convert their data to the new database. You can do this through a utility program or handle it
in your application when the updated application is first run. Files such as database drivers, the MFC DLLs, and controls do not need to be
included unless your update was developed using newer versions of these files.
Visual C++ 6.0 provides the InstallShield Wizard to create an InstallShield setup program which includes the necessary files and
dependencies to install your application, register the COM components, and allow for uninstall, as covered in Chapter 10. To start the
InstallShield Wizard, from the Tools menu select InstallShield Wizard as seen in Figure 11-11, or click the Start button on the desktop, select
Programs, then InstallShield for Microsoft Visual C++ 6.0.
Figure 11: Use the InstallShield Wizard to create an installation program for your application
The InstallShield Wizard will walk you through most of the process of creating an installation program for your application. The basic
procedure for creating an update is described in the following paragraphs.
The first step is to enter some basic information about your application. Include the name of the application and the name of the company that
wrote the application. Choose the development environment. Unless you have the full version of InstallShield, the only option available will
be Microsoft Visual C++ 6. Choose the type of application that you are deploying. The options available are: Database Application, Finance
Application, Internet Application, Software Development Application, and Statistical Application. enter the version of the update. The version
should represent the fact that this is an updated version of the application.
Next you will decide which dialog boxes to display during the installation process. Because this an update, you will generally want to
minimize the dialog boxes that are displayed. Which ones you choose will depend on your application and personal preferences. The
Welcome Message dialog box displays a welcome message and some information about running the installation program. The Software
License Agreement dialog box displays a license agreement for your update. The Readme Information dialog box displays some information
such as what is included in the update or warnings about performing the installation. Generally, you will give the user the option to view
update information when the setup is complete. The User Information dialog box asks the user to enter a Name, a Company, and a Serial
Number. You should have already retrieved this information from the user during the full installation and saved it in the Registry, so it
normally wouldnt be used. The Choose Destination Location dialog box allows the user to specify where to install the application files. This
information should already be in the Registry from the full installation. Normally, you would put code in the script to first check to see if this
information is in the Registry and then automatically install it there. If it is not there, then you could display this dialog box. The Setup Type
and Custom Setup dialog boxes normally wouldnt be used because you shouldnt need to ask the users which options to update. If you have a
large update that has some files that are only used in certain setup types, you could ask the user. However, this could cause problems if the
user didnt remember which option was selected during the full installation and selected the wrong one during the update. For example, say
the user did a Custom setup type during the full installation and then chose compact this time. Your update would only update the compact
files. This could cause problems. It would be better to retrieve the setup type from the Registry and use it if needed. The Select Program
Folder dialog box allows the user to specify in which Program folder on the Start menu a shortcut to the application will be placed. This
should have been done during the full installation and therefore not used during the update. The Start Copying Files dialog box displays the
setup options selected, which is not applicable to an update because you would retrieve this information from the Registry. The Setup
Complete dialog box notifies the user that the setup has completed and gives the user the option to view a Readme file and launch the
program. This is a better place to put information about your update rather than the Readme Information dialog box.
Now you need to choose on which operating systems the update can be installed. You will need to decide between Windows 95/98, Windows
NT 3.51 and Windows NT 4.0. For the Windows NT platforms, you will also decide between the Intel or Alpha platforms. Select the
operating systems that are absolutely necessary to reduce the size of your distributing package and reduce the chance that someone will try to
use your program under the wrong operating system. You can also select one or more languages for which you are running your setup.
You will also decide the components that wil be included in your update. You can group your files into components. Components and
subcomponents give you the flexibility to package your application and related software accessories into logical groups for setup types. These
components will be displayed to the user. Generally you will only need one component, such as the Program Files component, for the
executable and DLLs for your application. You will also decide on File Groups, which are related to the components. These are the actual file
groupings that will be installed.
When you are done, InstallShield will create the installation program using the options youve specified. InstallShield generates several files
including the setup rule (SETUP.RUL) file which is the script for the installation process. The SETUP.RUL file can be modified. It uses a
language similar to the C programming language. This file needs to be compiled when changes are made.
In Exercise 11.2, we will step through the Project Wizard to choose the options for an update. We are going to start InstallShield from the
Start menu because it has more options available than using the wizards.
Exercise 11-2 Choosing Update Options Using the Project Wizard in InstallShield
1. Start the InstallShield for Microsoft Visual C++ 6 from Start | Programs | InstallShield for Microsoft Visual C++ 6. Youll see the
Projects pane in the top window, as seen in Figure 11-12.
Figure 12: The Project Wizard of the InstallShield for Microsoft Visual C++ 6.0 helps you to create an update to your application
2. Double-click the Project Wizard icon to create your update. This will bring up the Project Wizard Welcome window.
3. For the Application name, enter Chapter 11_1 Update.
4. Enter a company name of your choice.
5. Select the development environment. Unless you have the full version of InstallShield, the only option available will be Microsoft
Visual C++ 6.0.
6. In the Application Type field, select Software Development Application
7. For the Application Version field, type 1.1.
8. Click the ellipsis button next to the Application Executable field to find the Chap11_1.EXE application that we created in exercise 11-1.
See Figure 11-13 for an example of how your completed Welcome screen should look.
Figure 13: Enter the information about your application on the Welcome screen
9. Click the Next button. This will bring up the Project WizardChoose Dialogs window. Here we need to decide which dialog boxes will
be displayed to the user. You can preview each of the dialog boxes by selecting one of the dialog boxes and then clicking the Preview button.
10. Select the Welcome Message dialog box.
11. Select the Software License Agreement dialog box.
12. Clear the check box for the Readme Information dialog box.
13. Clear the check box for the User Information dialog box.
14. Select the Choose Destination Location dialog box.
15. Clear the check boxes for the Setup Type and Custom Setup dialog boxes. For our exercise, we are only updating a small application, so
we dont need these dialog boxes.
16. Clear the check box for the Select Program Folder dialog box.
17. Clear the check box for the Start Copying Files dialog box. For our exercise, it is not applicable.
18. Select the Setup Complete dialog box. Your Choose Dialogs screen should look like Figure 11-14.
Figure 14: Choose the dialogs that you want to use in your setup from the Choose Dialogs screen
19. Click the Next button. This will bring up the Project WizardChoose Target Platforms dialog box. You can select the Show only
available platforms option to reduce the available platforms that the InstallShield program supports. We will use the defaults as displayed in
Figure 11-15.
Figure 15: Choose the platforms for your update from the Choose Target Platforms screen
20. Click the Next button. This will bring up the Project WizardSpecify Languages dialog box.
21. Select English. Your Specify Languages screen should look similar to Figure 11-16.
Figure 16: Use the Specify Languages screen to select the languages in which you will create your update setup
22. Click the Next button. Youll see a Project WizardSpecify Setup Types dialog box.
23. Cancel the selection of all of the options. We are not going to use Setup Types for this exercise. Your completed screen should look
similar to Figure 11-17.
Figure 17: Select your setup types from the Setup Types screen
24.Click the Next button. This will bring up the Project WizardSpecify Components dialog box.
25. Delete all of the components except the Program Files component. To delete a component, select the component and then click the Delete
button. We will only need the Program Files component for this exercise. Your completed screen should look similar to Figure 11-18.
Figure 18: You can add or delete components using the Specify Components screen
26. Click the Next button. This will bring up the Project WizardSpecify File Groups dialog box.
27. Delete all of the File Groups except the Program Executable Files. To delete file groups, select the File Group and then click the Delete
Button. In this exercise we will only be installing the executable. Your Specify File Groups screen should look similar to Figure 11-19.
Figure 19: Choose the file groups that you want your update to install from the Specify File Groups screen
28. Click the Next button. This will bring up the Project WizardSummary dialog box. At this point you should check the list of options to
make sure everything is correct.
29. Click the finish button. InstallShield will create the installation program using the options youve just specified. The InstallShield window
should look similar to Figure 11-20.
Figure 20: The InstallShield window after the frame code has been created for the setup program
Now that you have chosen the options for the update, you have some properties to set for the files that will be installed. You have to decide on
when they should be installed. On the Components tab, components have a property called Overwrite. The Overwrite property lets you specify
the conditions under which the files of the component will or will not overwrite existing files on the users computer. The available options
are as follows:
ALWAYSOVERWRITEoverwrites the file no matter what.
NEVEROVERWRITEinstalls the file only if it doesnt exist.
NEWERDATEoverwrites the file only if it has a newer date.
NEWERVERSIONoverwrites the file only if it has a newer version number.
NEWERVERSION/NEWERDATEfirst checks for a newer version, then if necessary, checks for a newer date.
Because we are creating an update, we want to overwrite existing files. Instead of using the default to always overwrite files, use the
Overwrite files by Version option. This way, if a user has run an update newer than the current update, it will not overwrite these files. As an
example, if you had ran Visual Studio Service Pack 3, then for whatever reason you run Service Pack 2, you would not want your files
updated by the older version. This could cause unpredictable results. In the File Groups tab, you will decide which files to include in the
update.
Exercise 11-3 Setting Properties for the Files to be Installed
Click the Components tab and select the Program Files component. The right pane will display the Components-Program Files window,
similar to Figure 11-21.
Figure 21: Use the Components Program Files window to view the current properties of the files that will be installed in the update
Double-click the Overwrite field. This will bring up the Overwrite Properties dialog box. Select the Overwrite files by Version option. The
Overwrite Properties dialog box should look similar to Figure 11-22.
Figure 22: Use the Overwrite Properties screen to specify when the distributed files will overwrite the users existing files
Click the OK button to use this option.
Click the File Groups tab. This will display the File Groups in the right pane. We will accept the defaults. It should look similar to Figure
11-23.
Figure 23: You can access the file group properties from the File Groups tab
Click the plus sign (+) next to the Program Executable Files folder icon. Then click the Links entry under it and youll see the File
GroupsProgram Executable Files\Links dialog box. This is where youll define the executable to include in this file group.
Right-click the File GroupsLinks dialog box and choose Insert Files from the shell extension menu. This will bring up the Insert File
Link(s) into File Group dialog box. This is a standard File Open dialog box.
Browse to the Chap11_1.EXE file, select it, and click OK. This will put the file in the Links window in the right pane, as shown in figure
11-24.
Figure 24: The selected program executable file for your update will appear in the Links window
The last step to deploy our update is to package it and choose the type of media by which our update will be distributed. By default, a
CD-ROM media package is created because the CD-ROM-based distribution is the most typical type. There are other widely used distribution
methods such as floppy disks, network-based, Web-based, and e-mail attachment package distributions.
Because CD-ROMs have a large amount of available space (over 600MB), the CD-ROM is often the medium of choice. To put your update
on a CD-ROM, you need a writeable CD-ROM drive attached to your deployment computer. Floppy disks are still a viable option. Some older
computers may not have a CD-ROM drive, so it is a good idea to have a floppy disk as an option. Also, if your update is less than 1.44Mb,
you might want to consider using floppy disks. The network-based distribution is very similar to the CD-ROM deployment method. If you
select the Folder option of the CD-ROM media type when you build the disk images, you can select a folder on a network server. This makes
deployment easy because you dont have to copy CD-ROMs or floppies and then distribute them. The Internet is an effective way of
distributing an application to the end users. Deploying a package through the Web requires you to have some sort of Internet access and
necessary permissions to a directory on a Web site. You also need to set up your Internet server to perform the user access and security
permission check in the directory. This is also a less expensive deployment method because you dont have to create and distribute CD-ROMs
or floppies. Another option is to attach the setup files to an e-mail message and send it to your users. Be careful about the size of the update.
Some Internet Service Providers will not let their customers receive e-mail attachments larger than 1Mb. In exercise 11-4, we will create a
package for distributing our update using floppy disk media.
Exercise 11-4 Creating Packages for a Floppy Disk distribution
1. Click the Media tab. We are now ready to choose the deployment options for our update.
2. Right-click the Chapter11_1 Update Media icon and select the Media Build Wizard. This will bring up the Media Build WizardMedia
Name screen. Enter Floppy for the Media Name. Notice that the default of CD-ROM is already created. We will create a floppy disk media
distribution type for this exercise because our update will be very small. Your screen should look similar to Figure 11-25.
Figure 25: Choose the media for your update from the Media Name screen
3. Click the Next button. This will bring up the Media Build WizardDisk Type screen. This screen allows you to choose the distribution
media for this media build. You can choose from different floppy disk sizes, CD-ROMs, custom sizes, and an Install From the Web option if
you have the InstallFromTheWeb Internet Setup Tool. This is another tool available from InstallShield to allow users to install your
application over the Internet.
4. Select 3.5 Diskette1.44 Mb and Click the Next button. This will bring you to the Media Build WizardBuild Type screen. Select
Full Build.
5. Click the Next button. This will bring up the Media Build WizardTag File screen. The purpose of tag files is to mark each disk of a
multidisk distribution. You can place application information in them. In the Tag File panel, the data is filled with the data that we entered
earlier. We will accept the defaults.
6. Click the Next button. This will bring up the Media Build WizardPlatforms screen. Select Windows 95 and Windows NT 4.0 (Intel).
7. Click the Next button. This will bring up the Media Build WizardSummary screen. This will display the options you have selected.
Look it over for errors.
8. Click the Finish button. This will generate the setup files needed for this media image. When it is complete, click the Finish button
again. This will bring us back to InstallShield.
9. To see the files that were created, click the plus sign (+) next to the Chapter 11_1 Update media icon. Click the plus sign next to the
Floppy icon. Click the plus sign next to the Disk Images icon. Click the Disk1 icon. The files for this image will be displayed in the right pane
as shown in Figure 11-26.
Figure 26: The setup files for the Floppy media image
10. To put your setup on a floppy disk, from the Build menu, select Send Media To This will bring up the Send Media ToSelect Media
screen. Select the Floppy Media Name as shown in Figure 11-27.
Figure 27: Use the Select Media screen to choose the media for your setup
11. Click the Next button. This will bring up the Send Media ToSelect Type screen. You can choose to put the media in a folder or on a
removable disk. Select Copy each disk in the media to a removable disk, as shown in Figure 11-28.
Figure 28: Use the Select Type screen to choose the location to which your media files will be copied
12. Click the Next button. This will bring up the Send Media ToSelect Removable Drive screen. This will allow you to choose the
removable drive on which the setup program is placed.
13. Select drive A: or the drive of your 3.5-inch floppy disk.
14. Click the Next button. This will bring up the Send Media ToStatus screen.
15. Click the Start button. When a floppy disk is in the drive, click OK on the message box that appears. A progress bar will appear that
shows the status of copying the files. When it is done, the screen will have a message telling you it was successfully copied.
16. Click the Close button. You have now created a setup program for your update and put it on a floppy disk.
Now that you have a better idea of how to fix errors and deploy updates, here are some possible scenario questions and their answers.
What is the difference between logic, syntax, and
run-time errors?
Logic errors occur when the results are not what
was expected, but there werent any syntax or
run-time errors. Syntax errors occur due to the
incorrect use of the programming language.
Run-time errors occur when an application attempts
an invalid action.
What happens if an exception occurs within my
exception handler?
The exception will be passed up the calling chain to
the procedure that called it until it finds an
exception handler. If an exception handler is not
found, your application will quit.
I have fixed some errors and added exception
handling to make my program more robust. How do
I get this update to my users?
Use InstallShield to create a setup program and only
include files that have changed. Create the
appropriate media types and distribute the update.
There are three basic type of errors: logic, syntax, and run-time. Logic errors are incorrect results without a run-time error. Syntax errors result
from using the programming language incorrectly. Visual C++ has some tools to help prevent syntax errors. Run-time errors are the result of
invalid actions, invalid data, or system conditions that prevent code from executing correctly. Run-time errors can cause your program to quit.
Exception handling is used to prevent run-time errors from stopping your application while it is running. It is important to incorporate
exception handling throughout your code to make it more robust. Both the MFC and the C++ programming language support exception
handling. Both of these methods use the try statement to enable exception handling and catch statements to handle any exceptions that occur
within the try statement block. The MFC provides some exception classes that are derived from the CException class. Exception handlers can
be nested and you must be able to determine the flow of execution through the calling chain.
Once you have fixed the errors, or updated the business rules, you need to create a setup program and deploy it to make it available to your
users. You will be distributing only the files that have changed in your update. You can use InstallShield to step you through the process. You
will determine which dialog boxes are displayed during setup, and which files will be included in the update during this process. You can
deploy your update using CD-ROMs, floppy disks, a network server, or over the Internet from a web site or by using e-mail attachments.
Two-Minute Drill
There are three basic types of errors in programming: logic, syntax, and run-time.
Logic errors are the cause when the results of your program are not what you expected. This situation is commonly referred to as a bug
in the code.
You can find some logic errors through code reviews and walkthroughs, but the best way is to test your program.
Syntax errors are the result of using the programming language incorrectly.
Run-time errors are errors that occur while the application is running.
To prevent errors from happening after you distribute your application, you need to implement error trapping and handling.
For run-time errors that occur because of conditions that are beyond a programs control, you should use exception handling and check
for common problems before executing an action.
The catch handlers are examined in order of their appearance following the try block.
There are different reasons for needing updates. It might be that because the business rules for your application have changed you are
adding new features, or you might have customers who discover some bugs that werent found during testing.
The first step to deploy your application is to package it.
You can deploy your update using CD-ROMs, floppy disks, a network server, or over the Internet from a web site or by using e-mail
attachments.
Visual C++ 6.0 provides the InstallShield Wizard to create an InstallShield setup program which includes the necessary files and
dependencies to install your application, register the COM components, and allow for uninstall.

Visual-C PDF

Uploaded by

Document Informationclick to expand document information

Copyright:

Available Formats

Visual-C PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Visual-C PDF

Uploaded by

Copyright:

Available Formats

Chapter 1: Introduction to Visual C++

Chapter 03: The Physical Design

Chapter 04: The User Interface

// TODO: Add your specialized creation code here

Chapter 06: Implementing ActiveX Controls

Chapter 07: Creating and Managing COM Components

if(myFileRead.Open(szMyFile, CFile::modeRead) //opens file for read only access

IMPLEMENT_SERIAL (CPayroll, CObject, 2 | VERSIONABLE_SCHEMA)

switch (schemaversion) //check version number

Chapter 08: Creating Data Services

Chapter 09: Testing and Debugging the Solution

Chapter 10: Distributing an Application

You might also like