On The Cover: December 2000, Volume 6, Number 12

December 2000, Volume 6, Number 12
Cover Art By: Arthur Dugoni
ON THE COVER
7 In Development
Implementing COM+ Events — Binh Ly
Binh Ly introduces the COM+ loosely-coupled event (LCE) system, and
demonstrates its three core concepts: the event class, the event publisher,
and the event subscriber.
FEATURES
13 On Language
New List Objects — Jeremy Merrill
Jeremy Merrill demonstrates classes from the new Contnrs unit, such
as TObjectList and TComponentList which can manipulate objects and REVIEWS
components without additional code. 31 LEADTOOLS Raster Imaging 12
Product Review by Bill Todd
18 Greater Delphi
Two Office Web Components — Alex Fedorov
Alex Fedorov puts two of the Office Web Components (OWC) through 34 Wireless Web Development
their paces, to easily add — for example — a bit of Microsoft Excel Book Review by Mike Riley
functionality to your Delphi applications.
36 Advanced Delphi Developer’s Guide to ADO
24 At Your Fingertips Book Review by Alan C. Moore, Ph.D.
Fancy Menus, etc. — Bruno Sonnino
Bruno Sonnino begins his new tips column by showing us how to
rotate text, create special lines, and customize menus with various fonts,
bitmaps, shapes, and colors. DEPARTMENTS
2 Symposium Guest Editorial by Michael Pence
29 Case Study 3 Delphi Tools
ASSESS — Denis Perrotti 6 Newsline
Denis Perrotti explains how Delphi was the perfect tool for developing
ASSESS, in contrast to the experience with Visual Basic and its requisite 37 Best Practices by Clay Shannon
tours of DLL hell and VBX purgatory. 38 File | New by Alan C. Moore, Ph.D.
1 December 2000 Delphi Informant Magazine
Symposium
I’ve Got a Secret
L et’s create a development environment that combines the ease-of-use of VB with the power of OOP and C++.
i Let’s make it component based, but still able to statically compile for maximum performance and minimal DLL
conflicts. We’ll have it support Microsoft technologies better and sooner than VB, and we’ll even create a Linux version
for cross-platform development.
Then let’s keep it a secret. Cordes, a Delphi and Java consultant and editor of The BDE Alter-
natives Guide at http://kylecordes.com/bag. Anthony DiAngelus, a
Sound familiar? If you’re a long-time Delphi developer, as I am, senior architect and consultant from Tampa, Florida concurs. “Unfor-
you recognize this truth-is-stranger-than-fiction scenario all too well. tunately, I’ve had to rely on my other skills as an Oracle DBA, rather
Through several management upheavals, countless premature obitu- than be a full-time Delphi developer. The work just isn’t there, and I
aries by industry pundits, and dizzying swings in business strategy, can only point the finger at the marketing group. Delphi is the best
there’s been one constant: pathetic marketing. development tool I have, but corporate America just doesn’t know
about it.”
We all slept through the “On Time, On Budget” campaign, carefully
synchronized with the “Inprise” branding fiasco. Now, as the Inprise Is it just a case of Borland being another aim-impaired David against
emblem has slowly crept into the shadow of the Borland name, we the Goliath of Redmond? Certainly, it’s not easy to market against
have the “Webvolutionaries” campaign, seemingly inspired by Elmer Microsoft’s tools division, which is heavily stocked with ex-Borland-
Fudd. Brilliant. ers, and has very deep pockets. However, companies like WebGain
(http://www.webgain.com) are successfully bundling top-quality tools
Borland makes better development tools than Microsoft, or anyone — and getting noticed. Just try to get through an InfoWorld or
else. They make the best application server out there, but who other trade magazine and not see them. Where is Borland’s bundling
would know? They are the Mercedes of developer tools, with the mar- strategy and marketing presence? Aiming to be Switzerland doesn’t get
keting strength of a Daewoo. Allaire, Embarcadero, Scour.com, and you on many people’s maps.
countless others leverage Delphi as their “secret weapon,” producing
top-notch software in record time, because they know The Secret. In their defense, Borland has begun, finally, to target the VB
Unfortunately, they’re in the minority. community with their latest campaign, featuring the promise of a
Linux-based RAD tool in Kylix (http://www.vbforlinux.com) and
On this late August day, Dice.com is trumpeting some 153,752 open aggressively distributing functional demonstration versions of Delphi
positions. Of those, only 627 are matches for jobs requiring Delphi. in publications like Visual Basic Programmer’s Journal. But is it too
That’s one in every 245 jobs, or 0.4%. Compare that to 14,950 Visual little, too late?
Basic jobs, approximately one in every 10, or 9.7%. And Java? Java
(not JavaScript) weighs in with 29,073 — one in every 5 jobs — or Kylix may be a reality by the time you read this, but the Linux market
18.9%! So our admittedly unscientific, but still relevant, search shows is still an emerging one. The Windows market will continue to
that, for every 200 IT jobs across the US, approximately 38 will be flourish for many years, and Delphi — the most powerful Windows
Java jobs, 20 will be Visual Basic jobs, and less than one will be a development environment available — will go the way of FoxPro
Delphi job. unless someone turns the lights on at Borland marketing.
The persistent lack of exposure of Delphi and other Borland tools — Michael Pence
has left those who have invested their time and talents in Borland
technologies scrambling to diversify. “Borland continues to make Michael Pence ([email protected]) lives in Phoenix with his wife, Denise, and
great solutions, but to attract desirable business I have added better- children, Ryan and Becca, and Sammy the puppy. He’s been an analyst and program-
marketed solutions from other vendors. Personally, I find myself mer for 10 years, using Java, Delphi, Visual Basic, and other tools. He is also founder
having to weigh the market presence of competing solutions as much, of The Delphi Advocacy Group (http://www.egroups.com/group/tdag), a mailing list
or more than, the technical aspects. Marketing matters,” notes Kyle for Delphi users.

Delphi Opaque Software Announces WithPalette 5 and WithView 5
Opaque Software announced the ers. WithView adds a toolbar Code Explorer can be brought
T O O L S release of WithPalette 5 and With- and a menu containing every forward when the Editor window
View 5, the latest versions of the open window in the IDE, allow- is used. The developer can also
New Products company’s IDE experts for Delphi ing the developer to select any make any window in the IDE a
and Solutions 4 and 5 and C++Builder 4 and 5. window with a click of the Stay-On-Top window or choose
WithPalette is an expert designed mouse. The keyboard can also be to place any window on the Win-
to enhance the IDE by making it used to select any window using dows Taskbar at the bottom of
easier for the developer to place the WindowSwitcher (similar to the screen.
components on forms. WithPal- pressing AT).
ette lets developers instantly add WithView can automatically Opaque Software
a component to any form with a “bring to front” the Object Price: US$19 each.
right-click of the mouse. Inspector when a form in the Phone: (707) 451-8357
WithPalette can be used with IDE is selected. Likewise, the Web Site: http://www.opaquesoftware.com
or without the IDE’s Compo-
nent palette. WithPalette allows
the developer to hide the stan-
dard IDE Component palette,
providing more screen space,
Win32 Multimedia API yet allow quick access to all pal-
Alan C. Moore, Ph.D. ette components. Also, WithPal-
Wordware Publishing, Inc. ette can be configured to give
quick access to favorite or most-
recently-used components.
WithView is designed to
enhance the IDE by making it
easier for developers to navigate
the various windows and design-
Global Majic Announces 3DLinX

Global Majic Software, Inc. design time. able as add-ons.
ISBN: 1-55622-666-7
announced 3DLinX, a real-time 3DLinX developers do not 3DLinX supports SGI RGB
Price: US$54.95
Web Site: http://www. graphic rendering engine and need to worry about incor- (RGB, RGBA, INT, INTA,
ComputerBookstore.com development tool designed to porating complex mathematics, BW); BMP; TGA (24- and
make realistic 3D applications accessing complex graphics 32-bit); TIF (uncompressed
easier to create. 3DLinX uses APIs, optimizing rendering 8-bit and 24-bit); and JPEG
COM and ActiveX to bring code, detecting collisions, (8-bit and 24-bit).
models to life that are aware implementing multi-threading 3DLinX also provides a mech-
of each other, interact with one optimizations, exploiting mul- anism for concealing valuable
Advanced Delphi Developer’s another, obey the laws of phys- tiple CPUs and hardware source code, as well as a linking
Guide to ADO ics, and have unique behavior acceleration, and applying tex- feature.
Alex Fedorov and Natalia Elmanova and characteristics. tures, transparencies, lights, 3D Add-on products can be
Wordware Publishing, Inc. Developers can command sounds, perspectives, projec- added to the 3DLinX architec-
properties, methods, and events tions, screen overlays, and other ture, including Living Models;
of 3DLinX objects. 3DLinX can complex functions. Keyframes and Inverse Kinemat-
be used with a developer’s favor- The 3DLinX Standard Edition ics capabilities for animators and
ite programming environment, includes loaders for importing game developers; and others.
including Delphi, C++Builder, models in 3D Studio, Version
Web pages, and others. It also 3.0 (.3ds); Open Flight, Version Global Majic Software, Inc.
provides design-time scene visu- 14.2, 15.x (.flt); and Cory- Price: US$895
alization, allowing the program- phaeus, Version 3.0-4.2 (.dwb). Phone: (877) 3DMAJIC
mer to interact with the scene at Additional loaders will be avail- Web Site: http://www.3dlinx.com
ISBN: 1-55622-758-2
Price: US$59.95
SilverLakeTech.com Announces PC Data Finder
Web Site: http://www. SilverLakeTech.com do Boolean, proximity, phrase, word in every document in
ComputerBookstore.com announced PC Data Finder, a and wildcard searches on the directories you choose to
PC search engine that enables documents in any directory index. This enables the user to
the user to find anything on a or drive. search for a document based on
hard drive or removable drive. PC Data Finder can also its content.
PC Data Finder will do search a user’s e-mail by Body,
searches through ZIPs, PDFs, Title, Keywords, Subject, SilverLakeTech.com
HTML, files with Office Suite Author, To, Date, Header, Price: US$99.55
extensions, and many others. Footer, or Operator. PC Data Phone: (973) 259-9300
PC Data Finder can also Finder works by indexing every Web Site: http://www.silverlaketech.com

Delphi TurboPower Announces Sleuth QA Suite 2
TurboPower Software Co. keyboard and mouse interac- services of the suite from their
T O O L S announced Sleuth QA Suite 2, tions for unattended, auto- own programs, without having
a new version of the company’s mated test suites. Recorded to use the tool’s user interface;
New Products quality assurance tools suite for actions can be saved as XML TurboPower’s Dynamic Instru-
and Solutions professional programmers. With data files. mentation technology; and an
Sleuth QA Suite 2, developers can In addition, all tools in Sleuth improved user interface with
find bugs, optimize program per- QA Suite 2 feature the ability full support for docking and
formance, and test the projects to export data from KeyViews access to syntax-highlighted
they develop. Sleuth QA Suite 2 to XML, HTML, or Microsoft source code and advanced dis-
includes five tools. Excel spreadsheet files; support assembly listings (where appli-
Sleuth CodeWatch tracks for all 32-bit versions of cable).
down hard-to-find memory and Borland Delphi, Borland
resource leaks; tests for improper C++Builder, and others; COM TurboPower Software Co.
use of Microsoft Windows API Automation support so devel- Price: US$399
calls; tests to ensure that API calls opers can access and use the Phone: (800) 333-4160
used in a program will be avail- debugging and optimization Web Site: http://www.turbopower.com
able on the developer’s target plat-
SQL Queries for Mere Mortals
Michael J. Hernandez and form; and reports errors to the
SkyLine Tools Imaging Releases Doc-to-Net 6.0
John L. Viescas line of source code where they SkyLine Tools Imaging pages within a multi-page TIFF
Addison-Wesley announced Doc-to-Net 6.0, a file; fewer required DLLs; a
start.
Sleuth StopWatch times pro- new version of the company’s UNC path name feature, allow-
gram execution at a macro level turnkey solution for sharing doc- ing files on different computers
and reports exactly how much uments over the Internet by within a system to be accessed
time is consumed by each routine transforming TIFF files to a by the same server; and password
in a project. Built-in KeyViews browser-compliant format. protection.
provide easy access to commonly Doc-to-Net 6.0 is a CGI appli- For photographic images, Doc-
required information, such as cation that transforms a scanned to-Net supports BMP, PCX, and
“The Top 10 Most Time Con- TIFF image to a PNG, GIF, or TGA files, and presents them as
suming Routines” and “The Top JPEG, then anti-aliases it “on JPEG, PNG, or GIF files. Image
ISBN: 0-201-43336-2 25 Most Called Routines.” the fly” and streams it through correction tools are provided for
Price: US$39.95 Sleuth LineProfiler times pro- the browser. This allows the end images.
Web Site: http://www.
gram execution at the source-line user to view the document with- Developers who wish to utilize
ComputerBookstore.com
level. Developers can get accurate out downloading any plug-ins. Doc-to-Net as a part of an inde-
timing statistics for any or all of Also included are zoom, pan, pendent programming applica-
the lines of their projects. and scroll features, plus rotating tion can leverage it as an add-on
Sleuth CoverageAnalyst tracks and inverting controls. to SkyLine Tools’ Corporate
the number of times individual New features in version 6.0 Suite. Doc-to-Net is royalty free.
lines of a project are executed and include a COM object for ASP
visually indicates the portions of pages, which will return the SkyLine Tools Imaging
Linux System Administration
the project that have not been number of pages in a multi-page Price: US$599
M. Carling, Stephen Degler,
and James Dennis adequately tested. TIFF file; the ability to recognize Phone: (818) 346-4200
New Riders Sleuth ActionRecorder records and return sizes of varied size Web Site: http://www.imagelib.com
Quest Announces Optional Module for TOAD

Quest Software, Inc. these tasks from within the space as needed.
announced TOAD DBA, an development environment. The original TOAD devel-
optional module for its TOAD TOAD DBA has a number opment software allows develop-
application development soft- of specific features that help ers to build, test, and debug
ware that adds database admin- with the most common database PL/SQL packages, procedures,
istration functionality to address management tasks, including triggers, and functions, and it
common Oracle database man- schema compare and synchro- allows users to create and edit
ISBN: 1-56205-934-3 agement tasks. nize, SQL data load and export, database tables, views, indexes,
Price: US$29.99 Utilizing a simple graphical and batch job scheduling and constraints, users, and roles.
Web Site: http://www.
ComputerBookstore.com
user interface, Oracle database management. It also provides the TOAD integrates with version
administrators have an easier ability to run DBA reports. control systems, schema manage-
way to handle database manage- Another significant feature is ment solutions, and SQL tuning
ment tasks, such as adding data Tablespace Management. Once and impact analysis tools.
files, managing disk space, creat- users confirm that a particular
ing or modifying user accounts, tablespace is nearly out of disk Quest Software, Inc.
implementing database security, storage space, they can log into Price: US$495
and creating or scheduling batch the database, confirm current Phone: (949) 754-8000
jobs — and they can perform space allocations, and add disk Web Site: http://www.quest.com

Delphi eHelp Launches RoboHELP Office 9.0
eHelp Corp. announced it systems for deployment on any editor with dozens of new features;
T O O L S is shipping RoboHELP Office platform. and enhanced WebHelp 4.0.
9.0, the latest version of the soft- RoboHELP Office 9.0 features
New Products ware tool for developing Help include integrated support for eHelp Corp.
and Solutions systems. RoboHELP Office 9.0 popular HTML editors, such Price: US$899
automates the process of creating as Dreamweaver, FrontPage, and Phone: (800) 358-9370
Help and assistance for Web HomeSite; a built-in HTML Web Site: http://www.ehelp.com/robohelp
sites and Web-based applica-
tions, allowing end users to
answer questions and resolve
problems themselves.
RoboHELP Office uses Help-
style navigation and features
that users are familiar with
from their desktop applications
(table of contents, index, full-
text search, associative linking,
Linux Essential Reference browse sequences, etc.).
Ed Petron
RoboHELP supports major
New Riders
online Help formats, including
WebHelp, Microsoft HTML
Help, WinHelp, JavaHelp,
Oracle Help for Java, and more,
and allows users to create Help
4Tier Software Announces OpenMOM

4Tier Software announced other applications become dis- objects between heterogeneous
the release of OpenMOM, which tributed communicating compo- software components via its
ISBN: 0-7357-0852-5 allows the deployment of nents deployed within a multi-tier asynchronous/synchronous mes-
Price: US$24.95 component-based distributed model over the Internet. saging infrastructure, as well as
Web Site: http://www. Internet applications. With Open- OpenMOM manages the interconnecting message brokers
ComputerBookstore.com MOM, Delphi, C/C++, Java, and exchange and morphing of that ensure maximum security,
load balancing, and the availabil-
ity of the distributed informa-
tion systems.
Some features of OpenMOM
include object morphing,
dynamic load balancing, multi-
Learning Red Hat Linux threaded architecture, broadcast
Bill McCarty and multicast messaging, fault
O’Reilly tolerant and multiple broker
architecture, and GUI-based
administration and configuration.
4Tier Software
Price: Free for development and deployment
with up to three computers connected.
Phone: (33) 1 39 76 80 20
Web Site: http://www.4tier.com
ISBN: 1-56592-627-7
Advanced Software Technologies Unveils GDPro 5.0
Price: US$34.95 Advanced Software Tech- sive visual blueprints of Java, mance enhancements, context-
Web Site: http://www. nologies, Inc. announced the C++, and IDL. sensitive pop-up Windows to
ComputerBookstore.com release of GDPro 5.0, an New features include a speed diagram population, and
upgrade to the company’s Web System Browser Report, a Rational Rose diagram import
UML visual modeling solution with functionality that allows feature.
for accelerating software design developers to produce and
and collaborative development. share comprehensive diagrams Advanced Software Technologies, Inc.
This new version allows appli- of their software designs over Price: US$2,995 for Windows; US$4,795
cation developers to create and the Internet. for Unix.
communicate across the enter- Other new features include Phone: (800) 811-2784
prise using simple, comprehen- Java Reverse Engineering perfor- Web Site: http://www.advancedsw.com

News It’s Time to Vote in the Delphi Informant Magazine Readers Choice Awards
Elk Grove, CA — Delphi Informant Magazine announced the official ballot for the 2001 Delphi
L I N E Readers Choice Awards is now available online at http://www.DelphiZine.com.
Each year, Delphi Informant Magazine recognizes outstanding products and vendors in the Delphi
add-on market that you select. Please take a moment to vote for your favorite Delphi tools in 19
December 2000 categories, including Best Book, Best Reporting Tool, and Product of the Year. Simply complete
the online ballot. This is your chance to voice your opinion regarding the tools and products you
use every day.
Voting ends January 31, 2001. The results will be published in the April 2001 issue of Delphi
Informant Magazine.
Inprise/Borland Announces JBuilder 4

Scotts Valley, CA — platform that supports Java 2 deploy EJB instantly without
Inprise/Borland announced Bor- JPDA, such as HP-UX, AIX, shutting down the application
land JBuilder 4, the latest Tru64. server.
version of its pure-Java cross- JBuilder 4 is integrated JBuilder 4 will be available in
platform development with the Borland Application three versions: JBuilder 4 Enter-
environment. JBuilder 4 sup- Server and supports BEA’s Web- prise, JBuilder 4 Professional,
ports Enterprise JavaBean (EJB) Logic server. Users can run and and JBuilder 4 Foundation. For
1.1-compliant development on debug EJBs and CORBA appli- more information, visit http://
Windows, Linux, and Solaris cations locally or remotely in www.borland.com/jbuilder, or
platforms. the JBuilder environment and call (800) 632-2864.
JBuilder 4 streamlines the con-
current management of source
Inprise/Borland Announces Availability of Inprise
code for large distributed teams Application Server 4.1
while extending existing source Scotts Valley, CA — Inprise/ enhanced EJB transaction sup-
code management across the Borland announced the ship- port with full two-phase commit
Internet. ment and availability of the VisiTransact, a transaction man-
JBuilder 4 features new visual Inprise Application Server 4.1. ager supporting JDBC 2.0/XA;
two-way tools, designers, and Inprise Application Server pro- VisiMessage; advanced object to
wizards, such as the entity Bean vides a foundation for cus- relational mapping for EJBs;
modeler, which shortens the tomers to deploy Internet integration support for Thought
development and deployment of applications with full support Inc.’s CocoBase and other third-
e-business applications; Internet- for Enterprise Java Bean (EJB) party O/R mapping tools; an
Beans, JSP, and servlets for and CORBA technology. This enhanced user interface; and
building data-driven Web appli- technology allows companies new wizards to simplify rolling
cations; support for Java 2 ver- whose business models are EJB applications out to multiple
sion 1.3 with built-in support based around large volumes of containers.
for the Sun Java HotSpot Virtual transactions, such as financial Inprise Application Server 4.1
Machine; JDataStore 4, a pure- institutions, to closely integrate is available immediately from
Java Object Relational Database their existing systems with the local Inprise/Borland offices, dis-
Management System for Web, new EJB environment. tributors, and representatives.
mobile, and embedded applica- New features of Inprise Appli- For more information on Inprise
tions; and remote debugging on cation Server 4.1 include Wire- Application Server, visit http://
Windows, Linux, Solaris, or any less Access Protocol support; www.borland.com/appserver.
Inprise/Borland to Support Intel Itanium Processor
San Jose, CA — Inprise/ including Itanium processor- opment in Intel microprocessor
Borland announced it will port based systems — will be com- architecture since the 386-pro-
Borland JBuilder, Inprise Appli- patible with what’s available on cessor introduction in 1985. The
cation Server, VisiBroker for IA-32 today. This will enable Itanium processor will com-
Java, and JDataStore for plat- companies who use Inprise/ plement today’s Pentium III
forms based on the Intel Ita- Borland’s integrated Java tool processor and Intel Pentium
nium processor. The software set to easily move their appli- Xeon 32-bit processor families
will be ported to the Microsoft cations running on IA-32-based with new features of high-end
Windows 2000 64-bit and Red systems today to IA-64-based scalability, reliability, availability,
Hat Linux 64-bit operating systems of tomorrow. and large memory addressability.
systems running Java 2 v1.3 The Intel Itanium processor More information on the Intel
runtime from IBM. All Inprise/ is the first in a family of IA-64 Itanium processor is available at
Borland offerings on Intel processors from Intel and is http://developer.intel.com/
IA-64 architecture (IA-64) — the most significant new devel- design/ia-64.

In Development
COM+ / Delphi 5 / Windows 2000
By Binh Ly
Implementing COM+ Events

Exploiting the Windows 2000 COM+ Event System
O ne of the more interesting features of COM+ (the new version of COM for Microsoft
Windows 2000) is the introduction of a new event mechanism for developing
scalable distributed systems. To appreciate the COM+ event system, it’s important to first
understand how events were implemented in the pre-COM+ era.
Pre-COM+ events fall into two main categories: between the event source and receiver. For
§ COM connection points are a standard instance, it can take an effort to implement
way of negotiating event interfaces between multiple event receivers (particularly as sepa-
the source and the receiver of the events. rate applications) to receive events from a
This structured negotiation is dictated by single event source.
the architecture of some standard COM
interfaces, such as IConnectionPoint and Because of these behaviors, the pre-COM+ event
IConnectionPointContainer. infrastructure is often referred to as a tightly cou-
§ COM callbacks are a low-level, application- pled event (TCE) system. The term “tightly cou-
specific way of negotiating event interfaces pled” denotes the strong and intimate dependency
between the source and the receiver of the between the event source and receiver objects.
events. This negotiation usually requires a
custom architecture, specific to an application A tightly coupled event system has its place, and
or part of an application. has been used successfully over the years, e.g. for
implementing the ActiveX controls event mecha-
I won’t go into the technical details of COM connec- nism. Unfortunately, with today’s applications rap-
tion points and COM callbacks; that’s not the goal idly moving toward high-speed, enterprise-scale
of this article. (For more information on these two environments, such as Web applications, new event
techniques, refer to my two-part series in the June requirements have surfaced that are difficult to sat-
and July 1998 issues of Delphi Informant Magazine.) isfy with a TCE solution.
One of the major characteristics of pre-COM+ A Hypothetical Retail Application

events is that the source and the receiver of events To introduce some of the requirements of a dis-
are tightly integrated: tributed event system, imagine that we are build-
§ Before events can be triggered, the event source ing the Purchase Order part of a hypothetical
and receiver must be simultaneously running retail application named the The Best. (The code
and available. If either is unavailable, no event for the sample application is available for down-
can be successfully triggered. load; see end of article for details.) Specifically,
§ The event receiver always has “pre-compiled” we’re in charge of an Order business component
knowledge of the event source. The event whose interface implements a simple purchase-
receiver will almost always know which par- order placement transaction as follows:
ticular COM class to instantiate as the event
source, and this knowledge is hard-coded and
IOrder = interface
compiled into the event-receiver application.
procedure PlaceOrder(CustomerID, ProductID,
§ The infrastructure is somewhat biased Quantity);
and caters to a one-to-one correspondence end;

In Development
CustomerID refers to the customer placing the order, ProductID This representation means that OrderEvents is an event class that
specifies the product being ordered, and Quantity specifies how implements the IOrderEvents interface, which contains an OrderPlaced
many products are being ordered. event method.
Let’s assume our business requirements are as follows: An important thing to understand about event classes is that we
1) Every time an order transaction is placed, an e-mail message must never implement the methods of the event class interface. We
be sent to a known back-end mail server, where another routine simply define the interface, and then install it into the COM+
will take control and start the process of filling the order. environment (see Figure 1).
2) Every time an order transaction is placed for a particular product
(ProductID), we’ll need to log that into the system. This log is To further understand what I mean, let’s take a look at the
used by other statistical applications that will analyze purchase Delphi implementation of an event class. Figure 2 illustrates the
patterns of customers and experimental products. Experimental OrderEvents event class (TheBestEvents.dpr). This module was
products change regularly, so it would be nice to have an imple- created using Delphi’s Automation Object Wizard (File | New
mentation for this that isn’t unduly impacted by product changes. | ActiveX | Automation Object) and using “OrderEvents” as the
CoClass name.
Obviously, a brute-force way to implement these requirements is to
hard-code the business processes into the IOrder.PlaceOrder imple-
mentation. However, we can look at these requirements from a
different angle, and conclude that we may want to trigger some kind
of event every time an order is placed. Other business processes or
components can then “listen in” on this event to perform the desired
operation, based on our current (and future) business requirements.
Using an event-based approach, it’s easy to see that:

§ Requirements 1 and 2 don’t need to be implemented by a
single business application/component; requirement 1 can be
implemented by one business component, and requirement 2 by
another. The only commonality among the business components
is that they both listen in on the same event. Furthermore, future
requirements can be implemented by adding newer business
components without modifying our existing application.
§ Requirements 1 and 2 don’t require an application continu- Figure 1: The OrderEvents event class definition as it appears in
ously running somewhere “out there,” listening for an event; the Type Library editor.
we only need to execute a business process/component when-
ever an event is triggered. unit
§ One powerful idea would be to allow easy configuration of each OrderEvents;
business component that listens in on the event, or even the

interface
configuration of the event itself. We might need to turn the
event on and off at certain times (such as when doing back-end uses
maintenance). We may also need to disable one business process Windows, ActiveX, Classes, ComObj, TheBestEvents_TLB,
StdVcl;
independently of the other. For example, we may need to tempo-
rarily disable the business component that handles requirement 2, // OrderEvents event class.
without affecting the business process handling for requirement 1. type
TOrderEvents = class(TAutoObject, IOrderEvents)
Unfortunately, the nature of pre-COM+ event systems, such as connec- protected
procedure OrderPlaced(
tion points and callbacks, does not meet these requirements. COM+
const CustomerID, ProductID: WideString;
introduces a new concept, called a loosely coupled event (LCE) system, Quantity: Integer); safecall;
for such enterprise-scale requirements. It’s based on three core concepts: end;
the event class, the event publisher, and the event subscriber.
implementation
COM+ Event Infrastructure uses

Using our example, we need some sort of concrete entity to represent ComServ;
the event that gets triggered every time IOrder.PlaceOrder is executed.
This concrete entity is called an event class. An event class is nothing procedure TOrderEvents.OrderPlaced(const CustomerID,
ProductID: WideString; Quantity: Integer);
more than a simple COM class (a CoClass plus interface) definition
begin
of the event. Let’s define our OrderEvents event class as follows: // Event class methods are not implemented.
end;
IOrderEvents = interface
prodecure OrderPlaced(CustomerID, ProductID, Quantity); initialization
end; TAutoObjectFactory.Create(ComServer, TOrderEvents,
Class_OrderEvents, ciMultiInstance, tmApartment);
OrderEvents = CoClass end.
implements IOrderEvents
end; Figure 2: This module describes the OrderEvents event class.

In Development
At this point, you might be wondering how this event is physically Subscribing to Events
triggered. The answer is simple: We create an instance of the Listening for a COM+ event is known as subscribing to the event. The
OrderEvents CoClass, and call the OrderPlaced method from party that subscribes to a COM+ event is called an event subscriber. An
that instance: event subscriber is physically implemented as a class that implements
uses uses
TheBestEvents_TLB; TheBestEvents_TLB;
procedure TriggerEvent; procedure TOrder.PlaceOrder(

var const CustomerID, ProductID: WideString;
OrderEvents: IOrderEvents; Quantity: Integer);
begin var
// Create OrderEvents event class. OrderEvents: IOrderEvents;
OrderEvents := CoOrderEvents.Create; begin
// Execute OrderEvents.OrderPlaced event. // Step 1:
OrderEvents.OrderPlaced('A Customer', 'A Product', 5); // Perform PlaceOrder business logic here.
end; // Example: Update Order table in database.
// Step 2:
To put that in context, let’s trigger this event from within the PlaceOrder // Trigger OrderEvents.
method of the Order business component, as shown in Figure 3. // Create OrderEvents event class.
OrderEvents := CoOrderEvents.Create;
The process of triggering a COM+ event works only if we properly // Execute OrderEvents.OrderPlaced event.
OrderEvents.OrderPlaced(CustomerID, ProductID, Quantity);
install the OrderEvents event class into the COM+ environment. The
end;
process of installing an event class for everybody to see is known as
publishing the event. The party that publishes an event is called the Figure 3: Triggering the event from the PlaceOrder method of
event publisher. In our case, the publisher of the OrderEvents event the TOrder class.
class is our retail application, The Best.
Publishing Events
An event class can be published administratively (interactively) or
programmatically. I will only demonstrate administrative publishing;
programmatic publishing requires knowledge of programmatic access
to the COM+ administration APIs that is beyond the scope of
this article. Before we can publish an event class, we first need to
build the COM server that defines the event class. This is contained
in the project, TheBestEvents.dpr. Building this project produces
TheBestEvents.dll, which we’ll install into the COM+ environment.
First, we’ll need to run the Component Services administration tool,

and create a new COM+ application in it. Component Services is
accessible from the Windows 2000 Control Panel, under Administra-
tive Tools | Component Services. To do this, right-click on COM+
Applications and select New | Application from the pop-up menu. The
COM Application Install Wizard will be displayed.
Figure 4: Component Services after creating an empty COM+
Select Create an empty application, and click on Next to advance to the application, The Best.
Create Empty Application screen. Then enter “The Best” as the name
for the new application, select Server application as the Activation type,
and click on Next to advance to the Set Application Identity screen.
Select Interactive user as the Account and click on Next. Click Finish
on the next screen to complete the wizard and return to Component
Services, where The Best will now appear as a new, empty COM+
application (see Figure 4).
The next step is to install OrderEvents as an event class into applica-

tion, The Best. To do this, right-click on Components under The Best,
and select New | Component. The COM Component Install Wizard
will be displayed (see Figure 5). Select Install new event class(es) and
click Next. Browse to the TheBestEvents.dll file, and select it to
advance to the Install new event class screen. Click Next, then Finish
to complete the wizard.
We’ve learned what an event class is, how it’s installed, and how it’s
called to trigger events. The next step is to understand how we can
listen in on an event. Figure 5: The COM Component Install Wizard.

In Development
the event interface(s) of a COM+ event class. A subscriber component display the pop-up menu, and select Insert Interface. Select
can be a persistent or a transient subscriber. A persistent subscriber is IOrderEvents from the displayed dialog box and click OK. The result
one that can be installed and administered via the COM+ environ- is shown in Figure 7.
ment. It doesn’t need to be running to receive event notifications. In
contrast, a transient subscriber cannot be administered via the COM+ Building the OrderLogger subscriber is very similar to EMailer.
environment, and must be running to receive event notifications. OrderLogger is also implemented in TheBestSubscribers.dpr, as shown
in Figure 8. This module was created using the Automation Object
For our purposes, we’ll build two persistent subscribers that
implement the two requirements mentioned earlier in this
article. The first subscriber implements sending out an e-mail
notification every time IOrderEvents.OrderPlaced is triggered.
Let’s call this subscriber EMailer. EMailer is implemented in
TheBestSubscribers.dpr, as shown in Figure 6. This module was
created using the Delphi Automation Object Wizard and using
“EMailer” as the CoClass name.
It’s important to point out that EMailer implements the IOrderEvents

event interface. More importantly, this needs to be reflected in
the type library information for EMailer. To do this, view the
TheBestSubscribers.tlb in the Delphi Type Library editor, and select
the Uses page. Right-click to display the pop-up menu, and select
Show All Type Libraries. Page down to TheBest Event Classes and select it.
Now we need to associate the IOrderEvents interface with the EMailer Figure 7: The EMailer CoClass in the Type Library editor.
CoClass. To do this, click on the EMailer CoClass (while still in the
Type Library editor), and select the Implements page. Right-click to unit OrderLogger;
unit EMailer; interface
interface uses
ComObj, ActiveX, TheBestSubscribers_TLB,
uses TheBestEvents_TLB, StdVcl;
ComObj, ActiveX, TheBestSubscribers_TLB,
TheBestEvents_TLB, StdVcl; // Order Log subscriber.
type
// EMailer subscriber. TOrderLogger = class(TAutoObject, IOrderLogger,
type IOrderEvents)
TEMailer = class(TAutoObject, IEMailer, IOrderEvents) protected
protected procedure OrderPlaced(
procedure OrderPlaced( const CustomerID, ProductID: WideString;
const CustomerID, ProductID: WideString; Quantity: Integer); safecall;
Quantity: Integer); safecall; procedure LogOrder;
procedure SendEMail; end;
end;
implementation
implementation
uses
uses ComServ, Dialogs, SysUtils;
ComServ, Dialogs, SysUtils;
// IOrderEvents.OrderPlaced subscription implementation.
// IOrderEvents.OrderPlaced subscription implementation. procedure TOrderLogger.OrderPlaced(
procedure TEMailer.OrderPlaced(const CustomerID, const CustomerID, ProductID: WideString;
ProductID: WideString; Quantity: Integer); Quantity: Integer);
begin begin
SendEMail; LogOrder;
ShowMessage('EMail Processing completed!' + #13 + ShowMessage('Order logging completed!' + #13 +
'Customer: ' + CustomerID + ', Product: ' + ProductID + 'Customer: ' + CustomerID + ', Product: ' + ProductID +
', Quantity: ' + IntToStr(Quantity)); ', Quantity: ' + IntToStr(Quantity));
end; end;
procedure TEMailer.SendEMail; procedure TOrderLogger.LogOrder;

begin begin
// Do e-mail business logic here. // Do logging business logic here.
end; end;
initialization initialization
TAutoObjectFactory.Create(ComServer, TEMailer, TAutoObjectFactory.Create(ComServer, TOrderLogger,
Class_EMailer, ciMultiInstance, tmApartment); Class_OrderLogger, ciMultiInstance, tmApartment);
end. end.
Figure 6: EMailer subscriber code. Figure 8: The OrderLogger unit.

In Development
wizard and using “OrderLogger” as the CoClass name. Also, note ponent Services utility. For our purposes, let’s install these into the
the important type library information included with the OrderLogger application we created earlier, i.e. TheBest.
CoClass, as shown in Figure 9.
To do this, right-click on Components under The Best in Components
With these, we are now ready to install EMailer and OrderLogger Services, and select New | Component. This will invoke the COM
into the COM+ environment. To do this, we first build Component Install Wizard. Select Install new component(s) at the
TheBestSubscribers.dpr, creating TheBestSubscribers.dll. We then Import or Install a Component screen, and click Next. Browse to
install both components into a COM+ application using the Com- TheBestSubscribers.dll file and select it to advance to the Install new
components screen (see Figure 10).
After installation, we then configure the event subscriptions. To

configure EMailer’s subscriptions, right-click on Subscriptions under
TheBestSubscribers.EMailer and select New | Subscription (as shown in
Figure 11) to display the COM New Subscription Wizard. The Select
Subscription Method(s) screen will be displayed; select IOrderEvents and
click Next. Then select TheBestEvents.OrderEvents at the select Event Class
screen and click Next. Make sure the Enable this subscription immediately
option is checked on the Subscription Options screen, click Next, then
Finish on the following screen to complete the wizard.
Figure 9: The OrderLogger definition in the Type Library editor.
Figure 12: Component Services after configuring the subscrip-

tions for EMailer and OrderLogger.
Figure 10: Installing EMailer and OrderLogger subscribers.
Figure 11: Invoking the COM New Subscription Wizard. Figure 13: Configuring OrderLogger’s subscription filter.

In Development
Next, perform the same process for OrderLogger subscription. When tents to “New Product” should produce a message box from the
you’re done, Component Services should look like Figure 12. OrderLogger subscriber.
Subscriber Filters Conclusion

Recall that one requirement for OrderLogger was that we want it This article has walked through a simple example for which the
to log transactions only for certain products. Although this business COM+ event system is a perfect solution. We’ve only scratched the
requirement can be realized by implementing conditional business surface of COM+ events, however. I hope this serves as a good
logic in TOrderLogger.OrderPlaced, we want the ability to configure introduction, and piques your interest enough for you to delve
this product filter administratively, so we can easily change the filtered more deeply into the details of implementing COM+ events in
product without a large maintenance impact on OrderLogger. your own applications. ∆
Fortunately, the COM+ event system has just the facility we need:
subscriber filters. A subscriber filter is a simple Boolean expression The files referenced in this article are available on the Delphi Informant
that’s evaluated to determine if a subscriber should be notified of Magazine Complete Works CD in INFORM\00\DEC\DI200012BL.
certain events. As an example, let’s assume we want to log orders
for an experimental product named “New Product.” This is easily
configured, as shown in Figure 13.
Note that Filter criteria uses the ProductID taken from the specified Binh Ly is an independent consultant who specializes in developing
parameter name in the IOrderEvents.OrderPlaced method. The filter distributed systems using COM technologies. He also maintains a Web site
criteria consists of a string Boolean expression. The expression is evalu- (http://www.techvanguards.com) that educates people on how to effectively
ated by the COM+ event system before instantiation of the subscriber use COM technologies using Borland products. You can reach Binh at
component. This provides for an efficient filtering mechanism in [email protected].
which subscribers aren’t unnecessarily instantiated if they aren’t “inter-
ested” in an event, based on certain conditions. The filter criteria can
also include Boolean operators, such as OR, AND, and NOT.
A Sample Application
Now that we’ve installed both subscriber business components,
we can then test their functionality. Before we do this, however,
let’s install the Order business component (discussed earlier) that
triggers the events. To do this, build the TheBest.dpr project and
install TheBest.dll into the COM+ environment. On my machine, I
simply added this into The Best.
To test the events, I’ve built a simple client application

(ExecuteOrder.dpr) that simulates a purchase order transaction (see
Figure 14). Performing a purchase order transaction is implemented
as shown in Figure 15.
Assuming you’ve
installed the event
classes and
subscriptions correctly,
executing the
Order.PlaceOrder oper-
ation should produce
a message box from
the EMailer subscriber.
Figure 14: A simple purchase-order
And changing the
client application.
Product edit box con-
uses
TheBest_TLB;
procedure TForm1.ExecuteOrderClick(Sender: TObject);

var
Order: IOrder;
begin
// Create Order business component.
Order := CoOrder.Create;
// Execute Order.PlaceOrder business transaction.
Order.PlaceOrder(CustomerID.Text, ProductID.Text,
StrToInt(Quantity.Text));
end;
Figure 15: Performing a purchase order transaction.

On Language
Delphi 5 / TList-related Classes / Contnrs Unit
By Jeremy Merrill
New List Objects

Delphi 5’s New Classes Increase TList Class Abilities
D elphi 5 introduced a new Contnrs unit that defines eight new classes, all based on
the standard TList class. In this article, we’ll provide an overview of the TList class,
then explore these eight new classes in detail. We’ll also look at how to create custom list
classes, ending with the creation of a new TList descendant class, TIntList.
The TList Class Anyone who’s used TList to maintain a list of

For those unfamiliar with a TList object, it simply objects will appreciate this feature. No more
stores a list of pointers. In many ways it’s like loops to free objects before freeing the TList
a dynamic array, with properties and methods object. No more freeing individual objects before
that allow addition, deletion, rearrangement, loca- their removal. No more memory leaks caused by
tion, access, and sorting of items within the bugs in the freeing code. This feature is so impor-
list. TList is often used to maintain a list of tant to this class that there’s even an overloaded
objects (see the tables in Figures 1, 2, and 3). Create constructor that allows the setting of the
OwnsObjects property when the
The TObjectList Class TObjectList object is created.
The primary class definition in the Contnrs unit
is TObjectList, which descends directly from the One final note on this topic: When OwnsObjects
TList class (see Figure 4). Given that most TList is True, the Extract method will remove the object
objects are used to store a list of objects, this new reference from the list, but will not free the
class may be the most useful contribution of the object. The Extract method was added to TList in
Contnrs unit. Delphi 5 for this purpose, even though the TList
implementation has Extract and Remove perform-
The first thing to notice about TObjectList is ing essentially the same function.
that Add, Remove, IndexOf, Insert, and Items all
expect a type of TObject instead of Pointer. This The last thing to notice about TObjectList is the
allows for more strict type checking at compile FindInstanceOf method. This function returns the
time, and removes the need to type cast item index of an object in the list that has the same class
pointers as TObjects. as the one passed as the argument for AClass. If
AExact is True, only instances of that class are found.
The second thing to notice is the addition of If AExact is False, objects that inherit from AClass
the OwnsObjects Boolean property. This property will also be found. The AStartAt parameter can be
is the fundamental difference between TList and used to find multiple instances of a class within the
TObjectList. When True (the default value), this list, continually calling the FindInstanceOf method
property directs TObjectList to free any objects with a starting index value one greater than the
removed from its list. This includes the use of index of the object last found, until FindInstanceOf
the Delete, Remove, and Clear methods, as well returns a -1. This is illustrated in the following code:
as when the TObjectList is itself destroyed. It’s
even smart enough to free an object that has been var
replaced by the insertion of a new object into an idx: Integer;
begin
existing list position.
idx := -1;
Name Type Description repeat
idx := ObjList.FindInstanceOf(TMyObject,
Count: Integer; property Returns the number of items in the list. True, idx+1);
Items[Index: Integer]: property Allows access to items in a zero-based list. if idx >= 0 then
Pointer; default ...
until(idx < 0);
Figure 1: Commonly used public properties of the TList class. end;

On Language
The TComponentList Class class definition. If a component in the list is freed (perhaps
The second class definition in the Contnrs unit is TComponentList by its owning form), then it will automatically be removed
(see Figure 5). Notice that TComponentList descends from from the TComponentList list. This is accomplished by using the
TObjectList, giving it all the capabilities of that class. Also notice TComponent.FreeNotification method, which causes components
that Add, Remove, IndexOf, Insert, and Items have all been in the list to notify the TComponentList object that they are about
changed to use a TComponent type. TComponentList has one addi- to be destroyed.
tional feature that is not obvious from looking at the public
The TClassList Class
Name Type Description The third class definition in Contnrs is TClassList,
Add(Item: Pointer): function Used to add a new item to the end of the list. shown in Listing One (beginning on page 15).
Integer; Unlike the previous two classes, this descendant of
Clear; procedure Used to clear out the list and reset the Count TList doesn’t add functionality. It simply changes
to zero. Add, Remove, IndexOf, Insert, and Items to use type
Delete(Index: Integer); procedure Used to remove a specific item by index. TClass. While this list would prove useful in
IndexOf(Item: function Used to find the list index of a specific item. certain programming situations, it’s perhaps just
Pointer): Integer; as useful as an example of how to create your
Insert(Index: Integer; procedure Used to insert an item into the list at a own custom TList descendant class. I’m including
Item: Pointer); specific index. the entire class definition here to illustrate how
Remove(Item: function Used to remove a specific item from the list, the supporting methods simply call the inherited
Pointer): Integer; without needing to know the item’s index. implementation of the same method.
Figure 2: Commonly used public methods of the TList class.
To create a TMyObjectList class, which descended
from either TList or TObjectList, you would
Name Type Description simply change all the references of TClass to
Capacity: Integer; property Allows precise control over memory allocation TMyObject, as shown in Listing Two (on page
for list. 16). Of course, once you have the basic frame-
Extract(Item: function Extract is identical to Remove except it work of a TMyObjectList class in place, adding
Pointer): Pointer; returns a reference to the item; may take on
methods or properties that use specific function-
different behavior.
Exchange(Index1, procedure Used to swap two items in the list.
ality of TMyObject would be a natural extension
Index2: Integer); of the class, as demonstrated by the DoSomething
First: Pointer; function Returns the first item in the list. procedure shown in Listing Two.
Last: Pointer; function Returns the last item in the list.
Move(CurIndex procedure Used to reposition item from indexes. TOrderedList, TStack, and TQueue Classes
NewIndex: Integer); Now we’ll look at three class definitions in the
Pack; procedure Removes all nil pointer elements from the list.
Contnrs unit at the same time, TOrderedList,
Sort(Compare: procedure Used to sort items in a list. Passed Compare
TStack, and TQueue, as shown in Figure 6.
TListSortCompare); routine is used to determine item order.
Notice that although TOrderedList does not
Figure 3: Some of the less common properties and methods of the TList class. descend from TList, it uses a TList object inter-
nally to store a list of items. Also notice that
TObjectList = class(TList) because the protected PushItem procedure is declared as abstract,
... the TOrderedList class is an abstract class.
public
constructor Create; overload;
constructor Create(AOwnsObjects: Boolean); overload; TOrderedList = class(TObject)
function Add(AObject: TObject): Integer; private
function Remove(AObject: TObject): Integer; FList: TList;
function IndexOf(AObject: TObject): Integer; protected
function FindInstanceOf(AClass: TClass; procedure PushItem(AItem: Pointer); virtual; abstract;
AExact: Boolean = True; AStartAt: Integer = 0): ...
Integer; public
procedure Insert(Index: Integer; AObject: TObject); function Count: Integer;
property OwnsObjects: Boolean; function AtLeast(ACount: Integer): Boolean;
property Items[Index: Integer]: TObject; default; procedure Push(AItem: Pointer);
end; function Pop: Pointer;
function Peek: Pointer;
Figure 4: Class declaration for TObjectList. end;
TComponentList = class(TObjectList) TStack = class(TOrderedList)

... protected
public procedure PushItem(AItem: Pointer); override;
function Add(AComponent: TComponent): Integer; end;
function Remove(AComponent: TComponent): Integer;
function IndexOf(AComponent: TComponent): Integer; TQueue = class(TOrderedList)
procedure Insert(Index: Integer; AComponent: TComponent); protected
property Items[Index: Integer]: TComponent; default; procedure PushItem(AItem: Pointer); override;
end; end;
Figure 5: Class declaration for TComponentList. Figure 6: TOrderedList, TStack, and TQueue.

On Language
Although Delphi prohibits creating an instance of an abstract class, Conclusion
TStack and TQueue are two descendant classes you can create Delphi 5 has provided us with several new classes that extend the
instances of. These two classes differ only in their implementation capabilities of the TList class. The TObjectList and TComponentList
of the protected PushItem procedure. As their class names suggest, classes allow us to store lists of objects or components without
TStack stores items in a last-in-first-out manner (or LIFO), and having to write additional supporting code. The TStack and TQueue
TQueue stores items in a first-in-first-out manner (or FIFO). Here’s a classes provide a more structured approach to using lists. While
brief look at the individual methods of both classes: TClassList, TObjectStack, and TObjectQueue are only simple exten-
§ Count returns the number of items in the list. sions of these classes, we’ve examined how to use these examples to
§ AtLeast can be used to check the size of the list; it returns True create custom list classes based on our own TMyObject class. We’ve
if the number of items in the list is greater than or equal to the even defined a new TIntList class that extends the capabilities of the
passed value. TList class to contain a list of integers. While the main intent of this
§ For TStack, Push adds an item to the end of the list. For TQueue, article has been to showcase the new classes provided in the Contnrs
Push inserts an item at the beginning of the list. unit, I also hope that I have instilled a better understanding of how
§ Pop returns an item from the end of the list, and removes it you can create custom list classes. ∆
from the list.
§ Peek returns an item from the end of the list, but leaves it in The files referenced in this article are available on the Delphi Informant
the list. Magazine Complete Works CD in INFORM\00\DEC\DI200012JM.
TObjectStack and TObjectQueue Classes

Now we’ll look at the last two class definitions in the Contnrs
unit, TObjectStack and TObjectQueue, shown in Listing Three (on
page 16). These two classes are simple extensions of the TStack Jeremy Merrill is an EDS contractor in a partnership contract with the Veteran’s
and TQueue classes, containing a list of TObjects instead of point- Health Administration. He is a member of the VA’s Computerized Patient Record
ers. Unlike the TObjectList class presented earlier, these classes do System development team, located in the Salt Lake City Chief Information Officer’s
not offer any new functionality. In most situations it wouldn’t Field Office.
make any sense for these lists to own their objects, because pop-
ping an object off the list would result in its destruction. These
classes use the same techniques as shown in the TClassList defini-
tion, calling inherited methods while converting between objects
and pointers. A close examination of these two classes demon-
strates how easy it would be to create a Begin Listing One — TClassList
TMyObjectStack or TMyObjectQueue class, as shown in Listing TClassList = class(TList)
Four (beginning on page 16). protected
function GetItems(Index: Integer): TClass;
The TIntList Class procedure SetItems(Index: Integer; AClass: TClass);
public
Up to this point, all the list classes we have looked at have
function Add(aClass: TClass): Integer;
been based on a list of pointers. The Object and Component function Remove(aClass: TClass): Integer;
lists are really lists of pointers, which just happen to point to function IndexOf(aClass: TClass): Integer;
TObjects or TComponents. We’ve even discussed how to create procedure Insert(Index: Integer; aClass: TClass);
custom TMyObject classes, which would essentially be a list of property Items[Index: Integer]: TClass
pointers that just happen to point to TMyObjects. read GetItems write SetItems; default;
end;
...
Now we’re going to define our own TList class that, instead of { TClassList }
containing a list of pointers, contains a list of integers. We’ll do function TClassList.Add(AClass: TClass): Integer;
this by creating a new IntList unit, which defines the TIntList class, begin
shown in Listing Five (on page 17). This class makes use of the fact Result := inherited Add(AClass);
end;
that pointers and integers both take the same amount of storage
space — four bytes. By typecasting pointers as integers, we can function TClassList.GetItems(Index: Integer): TClass;
store an integer value in the space reserved for a pointer. All the begin
supporting methods for this class simply call the inherited method Result := TClass(inherited Items[Index]);
or property, and include one or more typecast conversions between end;
pointers and integers. (The IntList unit is available for download;

function TClassList.IndexOf(AClass: TClass): Integer;
see end of article for details.) begin
Result := inherited IndexOf(AClass);
When looking at the TIntList class, notice that, in addition to the end;
Add, Remove, IndexOf, Insert, and Items redefinitions, we also redefine
procedure TClassList.Insert(Index: Integer;
First, Last, and Extract. The reason for this is that in TObjectList,
AClass: TClass);
TComponentList, and TClassList, these methods would still function, begin
because these classes are still dealing with pointers. In TIntList, these inherited Insert(Index, AClass);
methods would no longer function unless they were redefined as end;
using integers. Also notice the Sort method, which makes use of the
function TClassList.Remove(AClass: TClass): Integer;
TList sorting capabilities by passing the IntListCompare function to
the inherited Sort method.

On Language
begin inherited Items[Index] := AMyObject;

Result := inherited Remove(AClass); end;
end;
procedure TClassList.SetItems(Index: Integer;

End Listing Two
AClass: TClass);
begin Begin Listing Three — TObjectStack and TObjectQueue
inherited Items[Index] := AClass;
TObjectStack = class(TStack)
end;
public
procedure Push(AObject: TObject);
End Listing One function Pop: TObject;
function Peek: TObject;
Begin Listing Two — TMyObjectList end;
TMyObject = class(TObject) TObjectQueue = class(TQueue)

public public
procedure DoSomething; procedure Push(AObject: TObject);
end; function Pop: TObject;
function Peek: TObject;
TMyObjectList = class(TObjectList) end;
protected ...
function GetItems(Index: Integer): TMyObject; { TObjectStack }
procedure SetItems(Index: Integer; AMyObject: TMyObject); function TObjectStack.Peek: TObject;
public begin
function Add(aMyObject: TMyObject): Integer; Result := TObject(inherited Peek);
procedure DoSomething; end;
function Remove(aMyObject: TMyObject): Integer;
function IndexOf(aMyObject: TMyObject): Integer; function TObjectStack.Pop: TObject;
procedure Insert(Index: Integer; aMyObject: TMyObject); begin
property Items[Index: Integer]: TMyObject Result := TObject(inherited Pop);
read GetItems write SetItems; default; end;
end;
... procedure TObjectStack.Push(AObject: TObject);
{ TMyObjectList } begin
function TMyObjectList.Add(AMyObject: TMyObject): Integer; inherited Push(AObject);
begin end;
Result := inherited Add(AMyObject);
end; { TObjectQueue }
function TObjectQueue.Peek: TObject;
procedure TMyObjectList.DoSomething; begin
var Result := TObject(inherited Peek);
i: Integer; end;
begin
for i := 0 to Count-1 do function TObjectQueue.Pop: TObject;
Items[i].DoSomething; begin
end; Result := TObject(inherited Pop);
end;
function TMyObjectList.GetItems(Index: Integer): TMyObject;
begin procedure TObjectQueue.Push(AObject: TObject);
Result := TMyObject(inherited Items[Index]); begin
end; inherited Push(AObject);
end;
function TMyObjectList.IndexOf(AMyObject: TMyObject):
Integer;
begin
End Listing Three
Result := inherited IndexOf(AMyObject);
end; Begin Listing Four — TMyObjectStack and
procedure TMyObjectList.Insert(Index: Integer;
TMyObjectQueue
AMyObject: TMyObject); TMyObjectStack = class(TStack)
begin public
inherited Insert(Index, AMyObject); procedure Push(AMyObject: TMyObject);
end; function Pop: TMyObject;
function Peek: TMyObject;
function TMyObjectList.Remove(AMyObject: TMyObject): end;
Integer;
begin TMyObjectQueue = class(TQueue)
Result := inherited Remove(AMyObject); public
end; procedure Push(AMyObject: TMyObject);
function Pop: TMyObject;
procedure TMyObjectList.SetItems(Index: Integer; function Peek: TMyObject;
AMyObject: TMyObject); end;
begin ...

On Language
{ TMyObjectStack } end;
function TMyObjectStack.Peek: TMyObject;
begin function TIntList.First: Integer;
Result := TMyObject(inherited Peek); begin
end; Result := Integer(inherited First);
end;
function TMyObjectStack.Pop: TMyObject;
begin function TIntList.GetItem(Index: Integer): Integer;
Result := TMyObject(inherited Pop); begin
end; Result := Integer(inherited Items[Index]);
end;
procedure TMyObjectStack.Push(AMyObject: TMyObject);
begin function TIntList.IndexOf(Item: Integer): Integer;
inherited Push(AMyObject); begin
end; Result := inherited IndexOf(Pointer(Item));
end;
{ TMyObjectQueue }
function TMyObjectQueue.Peek: TMyObject; procedure TIntList.Insert(Index, Item: Integer);
begin begin
Result := TMyObject(inherited Peek); inherited Insert(Index, Pointer(Item));
end; end;
function TMyObjectQueue.Pop: TMyObject; function TIntList.Last: Integer;

begin begin
Result := TMyObject(inherited Pop); Result := Integer(inherited Last);
end; end;
procedure TMyObjectQueue.Push(AMyObject: TMyObject); function TIntList.Remove(Item: Integer): Integer;

begin begin
inherited Push(AMyObject); Result := inherited Remove(Pointer(Item));
end; end;
procedure TIntList.SetItem(Index: Integer;

End Listing Four const Value: Integer);
begin
Begin Listing Five — IntList.pas inherited Items[Index] := Pointer(Value);
end;
unit IntList;
function IntListCompare(Item1, Item2: Pointer): Integer;
interface
begin
if Integer(Item1) < Integer(Item2) then
uses
Result := -1
Classes;
else if Integer(Item1) > Integer(Item2) then
Result := 1
type
else
TIntList = class(TList)
Result := 0;
protected
end;
function GetItem(Index: Integer): Integer;
procedure SetItem(Index: Integer;
procedure TIntList.Sort;
const Value: Integer);
begin
public
inherited Sort(IntListCompare);
function Add(Item: Integer): Integer;
end;
function Extract(Item: Integer): Integer;
function First: Integer;
end.
function IndexOf(Item: Integer): Integer;
procedure Insert(Index, Item: Integer);
function Last: Integer; End Listing Five
function Remove(Item: Integer): Integer;
procedure Sort;
property Items[Index: Integer]: Integer
read GetItem write SetItem; default;
end;
implementation
{ TIntList }
function TIntList.Add(Item: Integer): Integer;
begin
Result := inherited Add(Pointer(Item));
end;
function TIntList.Extract(Item: Integer): Integer;

begin
Result := Integer(inherited Extract(Pointer(Item)));

Greater Delphi
ChartSpace and Spreadsheet ActiveX Components / Automation / Delphi 5
By Alex Fedorov
Two Office Web Components

Working with the OWC Chart and Spreadsheet Controls
O ne of the new and exciting features of Microsoft Office 2000 is its Office Web
Components (OWC), a set of ActiveX components intended for use from HTML
pages to create “active” Web documents. Since these components are simply ActiveX
components, however, we can also use them in non-Web applications built with Delphi.
This article shows you how.
The six ActiveX components that comprise the select Microsoft Office Web Components 9.0 (Version
OWC implement some of the functionality 1.0) from the list of available type libraries.
of Microsoft Excel, and provide database
access. The components are named ChartSpace, Since we’re dealing with ActiveX components,
Spreadsheet, DataSourceControl, RecordNaviga- we need to check the Generate Component Wrap-
tionControl, ExpandControl, and PivotTable. per option, select the Palette page where Delphi
DataSourceControl and RecordNavigationCon- will put the components wrappers (the default is
trol can be replaced with ADOExpress VCL ActiveX), and click Install. The six components
components (as we’ll see in this article), so will be added to the Component palette. As
they’re of no particular interest to Delphi devel- already mentioned, we’ll discuss only the Chart-
opers. ExpandControl is also outside the scope Space and Spreadsheet components.
of this article.
The type library file for the OWC is named
This leaves ChartSpace, Spreadsheet, and Pivot- MSOWC.DLL, and lives by default in \Program
Table. Unfortunately, I haven’t found a direct Files\Microsoft Office 2000\Office. The help file
way to make the PivotTable component work for the OWC is named MSOWCVBA.CHM,
in Delphi 5; it cannot be activated correctly for and lives in \Program Files\Microsoft Office
some reason. We can use still the component in 2000\Office\1033 by default.
Delphi, however, and in a future issue of this
magazine we’ll see the PivotTable component at The ChartSpace Component
work, and discuss accessing the Microsoft Excel As its name denotes, ChartSpace is used to
Pivot Table services. create charts. ChartSpace supports 46 types of
charts, from Line to Doughnut Exploded. See
As with many programming services available the ChartChartTypeEnum constants in OWC
through a type library — ActiveX components, help for the complete list. It can also draw charts
Automation servers, etc. — we need to create a from other members of the OWC (the Spread-
wrapper unit to use them. (This step is unneces- sheet component in our case), from ADO data
sary if you’re using late binding. In that case, sources, or from static data. In this article, we’ll
you can use Windows COM API functions to demonstrate how to do all three. (The demon-
create objects and variants to use the methods stration projects are available for download; see
and properties implemented in them. However, end of article for details.)
the easier way to deal with ActiveX components is
to create a wrapper unit.) To do so, select Project Charts Based on Static Data
| Import Type Library from the Delphi menu, and Static data is supplied by the application, i.e. it’s

Greater Delphi
hard wired. In Delphi appli- Axes collection), and legend (the Legend property). Figure 1 shows a
ChartSpace cations, we store such data simplified object hierarchy of the ChartSpace component (see OWC
in static variant arrays cre- Help for the complete diagram).
ated with the VarArrayCreate
Border function, or in dynamic Instead of giving you a detailed description of the ChartSpace com-
variant arrays created with ponent, and its objects and collections, let’s just look at an example
Interior the VarArrayOf function. that uses static data to create a chart. First, we need some variables:
Variant arrays. Let’s take var

WCCharts a brief refresher course on Chart : WCChart; // Chart
Series : WCSeries; // Series
the use of variant arrays.
XValues : Variant; // X-axis values
Static variant arrays hold
WCDataSources
items of type Variant. Such
arrays are created with the Now to manipulate the component. As indicated above, we need to
WCLegend VarArrayCreate function, clear the contents of the chart before we can use it:
and are filled on an item-
by-item basis, or in a ChartSpace1.Clear;
WCTitle loop. The following exam- ChartSpace1.Refresh;
Figure 1: Simplified ChartSpace ple shows how to create and
object model. fill a static variant array: Let’s create a new chart. To do this we need to add an item to
the Charts collection. Since this is the first chart, it has an index
var value of 0.
XValues : Variant;
...
Chart := ChartSpace1.Charts.Add(0);
// Create the variant array.
XValues := VarArrayCreate([0,2], varVariant);
// Load with data for the X-axis. Now, let’s add the title for the chart. First, we need to indicate that
XValues[0] := 'Element one'; our chart will have a title, then supply the text for the title.
XValues[1] := 'Element two';
XValues[2] := 'Element three';
Chart.HasTitle := True;
Chart.Title.Caption := 'Sales By Category';
When we call the VarArrayCreate function, we indicate the dimen-
sions of the variant array and the type of its items, varVariant in After that, we need to supply data. But first, because we’re using the
this case. In the example above, we’ve created a variant array with static data in this example, let’s create it. For the X-axis, we will use
three items of type Variant. a static variant array:
A dynamic variant array is created with the VarArrayOf function, XValues := VarArrayCreate([0,7], varVariant);
and isn’t associated with a particular variable. In the following XValues[0] := 'Beverages';
XValues[1] := 'Condiments';
example, the VarArrayOf function returns a one-dimensional array
XValues[2] := 'Confections';
of items of type Variant: XValues[3] := 'Dairy Products';
XValues[4] := 'Grains & Cereals';
VarArrayOf([104737, 50952, 78128, 117797, XValues[5] := 'Meat & Poultry';
52902, 80160, 47491, 62435])); XValues[6] := 'Produce';
XValues[7] := 'Seafood';
Now, let’s return to the ChartSpace component.

Now we can use this data to build our chart. The first step is to add the
To use the ChartSpace component we must perform several steps. new Series object to the SeriesCollection of our Chart (see Figure 2).
First, we have to clear the contents of the chart. Next, we need to
add a new Chart object to the Charts collection, which can hold up To illustrate, let’s add another series, and put the new chart on top of
to 16 charts. After that we can supply data for series (in the Series the existing one, as shown in Figure 3.
collection), set the title (the Title property), specify the axes (in the
Series := Chart.SeriesCollection.Add(0); Series := Chart.SeriesCollection.Add(1);

with Series do begin with Series do begin
// Set Series caption... // Set Series caption...
Caption := '1998'; Caption := '1999';
// ...and data. // ...and data.
SetData(chDimCategories, chDataLiteral, XValues); SetData(chDimCategories, chDataLiteral, XValues);
// Y-axes data will be taken from dynamic variant array. // Y-axes data is taken from the dynamic variant array.
SetData(chDimValues, chDataLiteral, VarArrayOf( SetData(chDimValues, chDataLiteral, VarArrayOf(
[104737, 50952, 78128, 117797, [20000, 15000, 36000, 56000,
52902, 80160, 47491, 62435])); 40000, 18000, 20000, 33000]));
// Set Chart type, Clustered Column in this case. // Set the Chart type, e.g. Line Markers.
Type_ := chChartTypeColumnClustered; Type_ := chChartTypeLineMarkers;
end; end;
Figure 2: Building a chart. Figure 3: Adding another chart to SeriesCollection.

Greater Delphi
To complete our first charting example, we just need to add Using DataSource from the OWC
an axis: Let’s start with the OWC DataSource component. First, we’ll declare
some variables:
Chart.Axes.Add(Chart.Axes[chAxisPositionLeft].Scaling,
chAxisPositionRight, chValueAxis); var
RSD : RecordsetDef; // Datasource
BarChart : WCChart; // Chart
and set some of its properties:
PieChart : WCChart; // Chart
Chart.Axes[chAxisPositionLeft ].NumberFormat := '$#,##0';

Chart.Axes[chAxisPositionRight].NumberFormat := '0'; Next, we’ll define the data source and the SQL statement
Chart.Axes[chAxisPositionLeft ].MajorUnit := 20000;
used to extract the data. For this example, we’re using the
Chart.Axes[chAxisPositionRight].MajorUnit := 20000;
sample Northwind database that comes with Microsoft Access
(Northwind.mdb). Specifically, we’re selecting data from the Cat-
Then we add a legend at the bottom part of our chart: egory Sales for 1997 view:
Chart.HasLegend := True; begin

Chart.Legend.Position := chLegendPositionBottom; DataSourceControl1.ConnectionString :=
'DRIVER={Microsoft Access Driver (*.mdb)};' +
'DBQ=C:\DATA\NORTHWIND.MDB';
The resulting chart is shown in Figure 4. So, we’ve seen how to use RSD := DataSourceControl1.RecordsetDefs.AddNew(
static data to draw charts with the ChartSpace component. In the 'SELECT * FROM [Category Sales for 1997]', 3, 'Sales');
next example, we will use data stored in a database.
Charts Based on Data from a Database Then, we clear the chart, and indicate the source of data:
When we need to build a chart based on data stored in a database,
we have two options. We can use DataSource from the OWC, or with ChartSpace1 do begin
we can use some ADO-compatible data source. As we will see later Clear;
Refresh;
in this article, the main sequence of actions is the same; the only
DataSource := DataSourceControl1.DefaultInterface as
difference is how the data sources are defined. MSDATASRC_TLB.DataSource;
DataMember := RSD.Name;
end;
Because the DataSource property of the ChartSpace component

is declared as an IUnknown-based interface (see the
MSDATASRC_TLB unit), we need to use the construction shown
here. (In Visual Basic, the statement is simpler — we just assign the
DataSourceControl1 value to the DataSource property. In this case, the
default interface will be found automatically.)
Using an ADO Data Source

Now, let’s see how we can use an ADO-compatible data source. To
do this, we’ll use Delphi’s ADOExpress components, i.e. components
on the ADO page of the Component palette. The ADOConnection
component is used to set the data source and cursor type, and the
ADOCommand component is used to extract data with a SQL
Figure 4: This line chart was created with static (hard wired) data. query. First, we declare a variable for the ADO recordset:
var
// Set the horizontal layout for the chart. RS : _Recordset; // ADO RecordSet
ChartSpace1.ChartLayout := chChartLayoutHorizontal;
// Add new Chart.
BarChart := ChartSpace1.Charts.Add(0); Then, the following code executes the SQL query, and associates the
with BarChart do begin returned data with the Chart:
// Set the type of Chart, a bar chart.
Type_ := chChartTypeBarClustered;
RS := ADOCommand1.Execute;
// The first field is categories.
with ChartSpace1 do begin
SetData(chDimCategories, 0, 0);
Clear;
// The second field is values.
Refresh;
SetData(chDimValues, 0, 1);
DataSource := RS as MSDATASRC_TLB.DataSource;
// Format the axes.
DataMember := '';
with Axes[chAxisPositionBottom] do begin
end;
NumberFormat := '0,';
MajorUnit := 25000;
HasMajorGridlines := False; Creating the Chart
end; After the source of the data is specified — with the OWC Data-
end;
Source, or through an ADO recordset — we can create our chart. To
Figure 5: Creating a bar chart. do so, we must add a new chart to the Charts collection, specify the

Greater Delphi
kind of data we will use, and add the axes. The code that does the After we’ve inserted data into the cells, we can use it to draw a chart.
job is shown in Figure 5. First, let’s clear the current chart and add a new Chart, then associate
it with data — this time with data stored in a Spreadsheet component
Now, let’s add another chart — a pie chart — based on the same data, (see Figure 8).
as shown in Figure 6. The resulting chart is shown in Figure 7.
Note that as in the previous examples in this article, we use the
Charts Based on Spreadsheet Data MSDATASRC_TLB.DataSource type to specify the default interface
In our third example, we’ll create a chart based on data stored in for the Spreadsheet component. Now we can “beautify” our chart, by
an OWC Spreadsheet component. When these two OWC ActiveX specifying titles for the axes and its types, as shown in Figure 9.
controls are used together like this, the chart will change its appear-
ance whenever the data in the spreadsheet is changed. After that, we can specify the maximum and minimum values for
axes, and set additional styles:
First, we need some variables:
Scalings[chDimXValues].Maximum :=
var Sheet.Range['A12', 'A12'].Value;
Sheet : WorkSheet; // Spreadsheet Scalings[chDimXValues].Minimum := 1;
Chart : WCChart; // Chart Scalings[chDimYValues].Maximum :=
Sheet.Range['B12', 'B12'].Value;
// Set additional styles.
Now we can fill the spreadsheet with some data: with SeriesCollection.Item[0] do begin
Marker.Style := chMarkerStyleDot;
Marker.Size := 6;
Sheet := Spreadsheet1.ActiveSheet;
Line.Set_Weight(1);
with Sheet do begin
end
Range['A1', 'A10'].Set_Formula('=Row()');
Range['B1', 'B10'].Set_Formula('=A1^2');
Range['A12','A12'].Set_Formula('=Max(A1:A10)');
Range['B12','B12'].Set_Formula('=Max(B1:B10)'); The resulting chart is shown in Figure 10.
end;
Again, this chart is “live;” if we change data in the Spreadsheet compo-
In the code above, we have inserted row numbers (from 1 to 10) in the nent, it will be automatically reflected in the ChartSpace component.
column A and its squared values in the appropriate column B. The cells
A12 and B12 contain the maximum values of the columns A and B. Now that we’ve seen how to use a Spreadsheet component as a source
of data for OWC charts, in the remaining part of this article, let’s see
As you can see, the Spreadsheet component allows us to use formulas, how to use the Spreadsheet component by itself.
which many users will recognize from using Microsoft Excel. You
can treat the Spreadsheet component like “Excel Lite;” they share the
same binary kernel. Knowing this allows us to use the Spreadsheet
component to perform some background calculations, without show-
ing the component itself on the screen.
// Add new chart.

PieChart := ChartSpace1.Charts.Add(1);
with PieChart do begin
// Set the type of chart, a pie chart.
Type_ := chChartTypePie;
// The first field is categories.
SetData(chDimCategories, 0, 0);
// The second field is values.
SetData(chDimValues, 0, 1);
// "Explode" segments of the pie.
SeriesCollection.Item[0].Explosion := 20;
// Add the legend...
HasLegend := True; Figure 7: The two charts created in Figures 5 and 6.
Legend.Position := chLegendPositionBottom;
// ...and title.
with ChartSpace1 do begin
HasTitle := True;
Clear;
Title.Caption := 'Sales by Category for 1997';
Refresh;
Title.Font.Set_Bold(True);
// Specify the datasource.
Title.Font.Set_Size(11);
DataSource := Sheet.Parent as MSDATASRC_TLB.DataSource;
WidthRatio := 75;
// Add new Chart.
// Data will be shown as percents.
Chart := Charts.Add(0);
with SeriesCollection.Item[0].DataLabelsCollection.Add do
// Set the type of Chart, Scattered Smooth Line Markers.
begin
Chart.Type_ := chChartTypeScatterSmoothLineMarkers;
HasValue := False;
// Specify data for X...
HasPercentage := True;
Chart.SetData(chDimXValues, 0, 'A1:A10');
Font.Set_Size(7);
// ...and Y values as a range of cells.
end
Chart.SetData(chDimYValues, 0, 'B1:B10');
...
end;
Figure 6: Adding a pie chart to the collection. Figure 8: Using a Spreadsheet component as the data source.

Greater Delphi
// Shows titles for the axes. § the name and path of the file as a string;
with Chart do begin § the symbol to use as the delimiter, e.g. tab, comma, etc.;
with Axes[chAxisPositionBottom] do begin
HasTitle := True;
§ a Boolean value that indicates how to treat consecutive
Title.Caption := 'X';
delimiters; and
Title.Font.Set_Size(8); § the text qualifier, which is a double quote by default.
MajorUnit := 1;
end; This LoadText statement, for example, will load data from a file named
with Axes[chAxisPositionLeft] do begin
Employee.txt, using the tab character (ASCII 9) as the delimiter:
HasTitle := True;
Title.Caption := 'X Squared';
Title.Font.Set_Size(8); SpreadSheet1.LoadText(
MajorUnit := 10; 'c:\data\Employee.txt', Chr(9), False, '"');
end;
...
After calling this method, our spreadsheet will be filled with the
Figure 9: Specifying titles for the chart’s axes. data contained in the specified text file. Alternatively, we can specify
data through the CSVData property (for comma-separated data), or
through the HTMLData property (for HTML-based data). Note that
HTML-based data is stored in Microsoft Excel-compatible format.
This should be kept in mind if you need to exchange data between
the Spreadsheet component and Excel.
In its current version, the Spreadsheet component doesn’t feature

database support per se. However, it’s easy to load data from an
ADO-compatible data source, as shown in Figure 12.
In this example, we’ve used Delphi’s ADOCommand component to

extract data from the Employees table in the Northwind database.
After that, we iterated through the records, and extracted data into
the cells of the Spreadsheet component.
After specifying the data, we can set properties for the cells. This
example changes the font of the first row:
Figure 10: A Spreadsheet component, and a chart using its data.
with Spreadsheet1.Range[Spreadsheet1.Cells.Item[1, 1],
The Spreadsheet Spreadsheet1.Cells.Item[1, RS.Fields.Count]].Font do
Component begin
Set_Name('Arial Narrow');
Spreadsheet The Spreadsheet component Set_Bold(True);
provides us with a programma- Set_Size(11);
ble kernel, which can be used end;
Pane
to perform various calculations
with a huge library of func- Here, we specify that the cells automatically adjust their size to their
Range tions. It also comes with an contents, and to left-align the contents of the cells:
easy-to-use graphical interface
for manipulating the cells of with Spreadsheet1.Range[Spreadsheet1.Cells.Item[1, 1],
TitleBar the spreadsheet. Spreadsheet1.Cells.Item[NumRecs, RS.Fields.Count]] do
begin
AutoFitColumns;
Worksheet The object model of the Set_HAlignment(ssHAlignLeft);
Spreadsheet component (see end;
Figure 11: Simplified object
Figure 11) contains the
model for the Spreadsheet
ActiveSheet property, which
component.
gives us access to an individual The resulting spreadsheet is shown in Figure 13.
sheet within the component;
and such objects as Pane (the work area of the spreadsheet), Range Setting Colors
(for a range of cells), TitleBar ( the title bar for the spreadsheet), and Before we end our discussion of Microsoft Office Web Compo-
Worksheet (for the spreadsheet itself ). Again, see OWC Help for the nents, let’s briefly talk about setting colors. If you try to change the
complete diagram. color of an element of a Chart or Spreadsheet component, you’ll
find that the Color property is read-only. This is due to a bug in the
There are many ways to insert data into the Spreadsheet compo- Delphi type-library parser.
nent. For example, we can enter it manually, use copy and paste
(the Clipboard), load data from Microsoft Excel or Word, load To solve this problem, we must use the more round-about Set_Color
data stored in text file or Web site, etc. method. Another nuisance is that this method takes an argument of
type POleVariant1. A closer inspection of the type-library interface
To load data from a text file, we can use the Spreadsheet’s LoadText code shows that this type is defined as a pointer to OLEVariant. The
method, which takes the following arguments: following code shows how to use the Set_Color method:

Greater Delphi
var It’s important to note that these components can only be used
C : OLEVariant; on computers with one of the following products installed: Office
...
2000 Standard, Office 2000 Premium, Office 2000 Professional,
// We can use predefined colors...
C := OLEVariant('CornSilk'); Office 2000 Small Business, Office 2000 Developer, or Access
// ...or 16-bit RGB values. 2000. According to the Microsoft Licensing Agreement, we can
C := OLEVariant(RGB($C0, $C0, $C0)); use these components only on the local computers and Intranet.
... For more information refer to http://www.microsoft.com/Office/
Spreadsheet1.ActiveSheet.UsedRange.Interior.Set_Color(@C);
evaluation/prodinfo/license.htm. ∆
Conclusion The files referenced in this article are available on the Delphi Informant
So there you have it. We’ve seen how to use two Microsoft Office Magazine Complete Works CD in INFORM\00\DEC\DI200012AF.
Web Components in Delphi applications, so you can add two more
ActiveX components to your bag of tricks.
Alex Fedorov is executive editor for ComputerPress magazine published in Moscow,

procedure TForm1.Button1Click(Sender: TObject);
Russia. He is co-author of Professional Active Server Pages 2.0 and ASP 2
var
RS : _RecordSet; // ADO Recordset
Programmer’s Reference published by Wrox, as well as Advanced Delphi Develop-
I,J : Integer; // Counters er’s Guide to ADO, published by Wordware Publishing. You can visit his Web site
NumRecs : Integer; // Number Of Records at http://d5ado.homepage.com.
begin
// Execute SQL query.
RS := ADOCommand1.Execute;
// Move to the first record.
RS.MoveFirst;
// Clear the spreadsheet.
Spreadsheet1.ActiveSheet.Cells.Item[1, 1].Select;
Spreadsheet1.ActiveSheet.UsedRange.Clear;
// Set the titles for columns.
J := 0;
for I := 0 to RS.Fields.Count-1 do begin
Inc(J);
Spreadsheet1.ActiveSheet.Cells.Item[1, J].Set_Value(
RS.Fields[I].Name)
end;
// Set the data.
I := 1;
while NOT RS.EOF do begin
for J := 1 to RS.Fields.Count do
Spreadsheet1.ActiveSheet.Cells.Item[I+1, J].
Set_Value(VarToStr(RS.Fields[J-1].Value));
// Move to the next record.
RS.MoveNext;
Inc(I)
end;
NumRecs := I;
end;
Figure 12: Loading data from an ADO-compatible data source

into a Spreadsheet component.
Figure 13: A sample Spreadsheet component.

At Your Fingertips
Custom Menus, Text, Lines / Delphi 4, 5
By Bruno Sonnino
Fancy Menus, etc.

Custom Menus, Rotated Text, and Special Lines
B efore Delphi 4, it was difficult to customize a menu (add a bitmap, change a font,
ietc.), because owner drawing (i.e. custom drawing) — although implemented by
Windows — was not exposed by the TMainMenu class. Since Delphi 4, however, this
situation has been rectified, and we can have our way with menus.
This article will highlight some techniques property of the menu component — TMainMenu
you can use to customize the appearance of or TPopupMenu — to True, and provide event
menus in your Delphi applications. We’ll discuss handlers for its OnDrawItem and OnMeasureItem
text placement, menu sizing, font assignment, events. For example, an OnMeasureItem event
and using bitmaps and shapes to enhance a handler is declared like this:
menu’s appearance.
procedure TForm1.Option1MeasureItem(
Sender: TObject; ACanvas: TCanvas;
Just for fun, this article also features techniques
var Width, Height: Integer);
for creating rotated text and custom lines. All
of the techniques discussed in this article are
demonstrated in projects available for download; Set the Width and Height variables to adjust the
see end of article for details. size of the menu item. The OnDrawItem event
handler is where all the hard work is done; it’s
Custom Fonts and Sizes where you draw your menu and make any special
To create a custom menu, set the OwnerDraw settings. To draw the menu option with Times
New Roman font, for example, you should do
procedure TForm1.Times2DrawItem(Sender: TObject;
something like this:
ACanvas: TCanvas; ARect: TRect; Selected: Boolean);
var
dwCheck : Integer; procedure TForm1.Times1DrawItem(
MenuCaption : string; Sender: TObject; ACanvas: TCanvas;
begin ARect: TRect; Selected: Boolean);
// Get the checkmark dimensions. begin
dwCheck := GetSystemMetrics(SM_CXMENUCHECK); ACanvas.Font.Name := 'Times New Roman';
// Adjust left position. ACanvas.TextOut(ARect.Left+1, ARect.Top+1,
ARect.Left := ARect.Left + LoWord(dwCheck) + 1; (Sender as TMenuItem).Caption);
MenuCaption := (Sender as TMenuItem).Caption; end;
// The font name is the menu caption.
ACanvas.Font.Name := 'Times New Roman';
// Draw the text. This code is flawed, however. If it’s run, the
DrawText(ACanvas.Handle, PChar(MenuCaption), menu caption will be drawn aligned with the
Length(MenuCaption), ARect, 0); left border of the menu. This isn’t default Win-
end; dows behavior; usually, there’s a space to put
Figure 1: This OnDrawItem event handler places menu item bitmaps and checkmarks in the menu. There-
text correctly. fore, you should calculate the space needed for a

At Your Fingertips
checkmark with code like that shown in Figure 1. Figure 2 shows design time, or with code at run time. To draw colored rectangles as
the resulting menu. the caption of a menu item, you could use the OnDrawItem event
handler shown in Figure 4. Figure 5 shows the result.
If the text is too large to be drawn in the menu, Windows will cut
it to fit. Therefore, you should set the menu item size so all the text There’s just one catch. If you’re using Delphi 5, you must set
can be drawn. This is the role of the OnMeasureItem event handler the menu’s AutoHotkeys property to maManual. If you leave it as
shown in Figure 3. the default, maAutomatic, Delphi will add an ampersand character
(&) to the caption, which will break this code. Another solution is
Custom Shapes and Bitmaps to remove the ampersand with the StripHotKey function.
It’s also possible to customize menu items by including bitmaps
or other shapes. To add a bitmap, simply assign a bitmap file to
the TMenuItem.Bitmap property — with the Object Inspector at
Figure 5: A menu featuring colored rectangles as items.
procedure TForm1.VerticalDrawItem(Sender: TObject;

Figure 2: A menu drawn with custom fonts. ACanvas: TCanvas; ARect: TRect; Selected: Boolean);
var
lf : TLogFont;
procedure TForm1.Times2MeasureItem(Sender: TObject; OldFont : HFont;
ACanvas: TCanvas; var Width, Height: Integer); clFore, clBack : LongInt;
begin Rectang : TRect;
ACanvas.Font.Name := 'Times New Roman'; dwCheck : LongInt;
ACanvas.Font.Style := []; MenuHeight : Integer;
// The width is the space of the menu check begin
// plus the width of the item text. dwCheck := GetSystemMetrics(SM_CXMENUCHECK);
Width := GetSystemMetrics(SM_CXMENUCHECK) + // This will be done once, when the item is selected.
ACanvas.TextWidth((Sender as TMenuItem).Caption) + 2; if Selected then begin
Height := ACanvas.TextHeight( // Create a rotated font.
(Sender as TMenuItem).Caption) + 2; FillChar(lf, SizeOf(lf), 0);
end; lf.lfHeight := -14;
lf.lfEscapement := 900;
Figure 3: This OnMeasureItem event handler insures that an item lf.lfOrientation := 900;
fits in its menu. lf.lfWeight := Fw_Bold;
StrPCopy(lf.lfFaceName, 'Arial');
// Select this font to draw.
procedure TForm1.ColorDrawItem(Sender: TObject; OldFont := SelectObject(ACanvas.Handle,
ACanvas: TCanvas; ARect: TRect; Selected: Boolean); CreateFontIndirect(lf));
var // Change foreground and background colors.
dwCheck : Integer; clFore := SetTextColor(ACanvas.Handle, clSilver);
MenuColor : TColor; clBack := SetBkColor(ACanvas.Handle, clBlack);
begin // Get the menu height.
// Get the checkmark dimensions. MenuHeight := (ARect.Bottom-ARect.Top) *
dwCheck := GetSystemMetrics(SM_CXMENUCHECK); ((Sender as TMenuItem).Parent as TMenuItem).Count;
ARect.Left := ARect.Left + LoWord(dwCheck); Rectang := Rect(-1, 0, dwCheck-1, MenuHeight);
// Convert the caption of the menu item to a color. // Draw the text.
MenuColor := ExtTextOut(ACanvas.Handle, -1, MenuHeight, Eto_Clipped,
StringToColor((Sender as TMenuItem).Caption); @Rectang, 'Made in Borland', 15, nil);
// Change the canvas brush color. // Returns to the original state.
ACanvas.Brush.Color := MenuColor; DeleteObject(SelectObject(ACanvas.Handle, OldFont));
// Draws the rectangle. If the item is selected, SetTextColor(ACanvas.Handle, clFore);
// draw a border. SetBkColor(ACanvas.Handle, clBack);
if Selected then end;
ACanvas.Pen.Style := psSolid // Draw the real menu text.
else ARect.Left := ARect.Left + LoWord(dwCheck) + 2;
ACanvas.Pen.Style := psClear; DrawText(ACanvas.Handle,
ACanvas.Rectangle(ARect.Left, ARect.Top, PChar((Sender as TMenuItem).Caption),
ARect.Right, ARect.Bottom); Length((Sender as TMenuItem).Caption), ARect, 0);
end; end;
Figure 4: Using the OnDrawItem event to draw colored
rectangles on menu items. Figure 6: Using OnDrawItem to draw vertical text on a menu.

At Your Fingertips
procedure TForm1.FormPaint(Sender: TObject);

var
OldFont, NewFont : hFont;
LogFont : TLogFont;
i : Integer;
begin
// Get handle of canvas font.
OldFont := Canvas.Font.Handle;
i := 0;
// Transparent drawing.
SetBkMode(Canvas.Handle, Transparent);
// Fill LogFont structure with information
// from current font.
Figure 7: Menu with vertical text. GetObject(OldFont, Sizeof(LogFont), @LogFont);
// Angles range from 0 to 360.
while i < 3600 do begin
function CreateFont(
nHeight, // Logical height of font. // Set escapement to new angle.
nWidth, // Logical average character width. LogFont.lfEscapement := i;
nEscapement, // Angle of escapement. // Create new font.
nOrientation, // Base-line orientation angle. NewFont := CreateFontIndirect(LogFont);
fnWeight: Integer; // Font weight. // Select the font to draw.
fdwItalic, // Italic attribute flag. SelectObject(Canvas.Handle, NewFont);
fdwUnderline, // Underline attribute flag. // Draw text at the middle of the form.
fdwStrikeOut, // Strikeout attribute flag. TextOut(Canvas.Handle, ClientWidth div 2,
fdwCharSet // Character set identifier. ClientHeight div 2, 'Rotated Text', 21);
fdwOutputPrecision, // Output precision. // Clean up.
fdwClipPrecision, // Clipping precision. DeleteObject(SelectObject(Canvas.Handle, OldFont));
fdwQuality, // Output quality. // Increment angle by 20 degrees.
fdwPitchAndFamily: DWORD; // Pitch and family. Inc(i, 200);
lpszFace: PChar // Pointer to typeface name string. end;
): HFONT; stdcall; end;
Figure 8: The Object Pascal declaration for the CreateFont Win-

dows API function. Figure 10: Code to draw text rotated in 20-degree intervals.
One tricky detail is knowing where to begin drawing the text. It

tagLOGFONTA = packed record should begin at the bottom of the last item on the menu. To get its
lfHeight: Longint;
lfWidth: Longint;
position, we get the height of the menu item, using:
lfEscapement: Longint;
lfOrientation: Longint; ARect.Top - ARect.Bottom
lfWeight: Longint;
lfItalic: Byte;
and multiply it by the number of items in the menu:
lfUnderline: Byte;
lfStrikeOut: Byte;
lfCharSet: Byte; (((Sender as TMenuItem).Parent as TMenuItem).Count)
lfOutPrecision: Byte;
lfClipPrecision: Byte;
lfQuality: Byte;
Rotated Text
lfPitchAndFamily: Byte;
The Windows API allows you to draw text at any angle. To do
lfFaceName: array[0..LF_FACESIZE - 1] of AnsiChar; this in Delphi, you must use the API function CreateFont or
end; CreateFontIndirect. CreateFont is declared as shown in Figure 8.
TLogFontA = tagLOGFONTA;
TLogFont = TLogFontA;
While this function has many parameters, you will usually want to
change only one or two attributes of the text. In such cases, you
Figure 9: The TLogFont record.
should use the CreateFontIndirect function instead. It takes only one
argument — a record of type TLogFont, as shown in Figure 9.
Another way to use the OnDrawItem and OnMeasureItem events is to
write text vertically on a menu (as shown in Figure 7). To do this, you Looking at this record, you’ll notice its members match the
must create a rotated font. This is only possible using the Windows API parameters for the CreateFont function. The advantage of using
function CreateFont or CreateLogFont (see the “Rotated Text” tip later this function/record combination is that you can fill the record’s
in this article). members with a known font using the GetObject API function,
change the members you want, and create the new font.
Then you must draw it in the OnDrawItem event handler. This
event is fired every time a menu item is drawn, so if a menu To draw rotated text, the only member you must change is lfEscapement,
has 20 items, it will be drawn 20 times. To make it faster, the which sets the text angle in tenths of degrees. So, if you want text drawn
vertical text will be drawn only when the menu item is selected at 45 degrees, you must set lfEscapement to 450.
(since there’s is only one menu item selected at a time). Figure
6 shows how this is implemented with code, and Figure 7 shows Notice that there are flags to draw italic, underline, and strikeout text,
the run-time result. but there is no flag to draw bold text. This is done with the lfWeight

At Your Fingertips
function LineDDA(
// x-coordinate of line's starting point.
nXStart,
// y-coordinate of line's starting point.
nYStart,
// x-coordinate of line's ending point.
nXEnd,
// y-coordinate of line's ending point.
YEnd : Integer;
// Address of application-defined callback function.
lpLineFunc : TFNLineDDAProc;
lpData : LPARAM // Address of application-defined data.
): BOOL; stdcall;
Figure 13: Object Pascal declaration for the Windows API func-
tion, LineDDA.
Figure 11: Text rotated 360 degrees.
type
TForm1 = class(TForm)
procedure TForm1.Info1Click(Sender: TObject); ImageList1: TImageList;
var procedure FormPaint(Sender: TObject);
LogFont : TLogFont; procedure FormResize(Sender: TObject);
begin end;
// Fill LogFont structure with information
// from current font. var
GetObject(Canvas.Font.Handle, Form1: TForm1;
Sizeof(LogFont), @LogFont);
// Display font information. procedure CallDDA(x, y: Integer; Form: TForm1); stdcall;
with LogFont do
ShowMessage( implementation
'lfHeight: ' + IntToStr(lfHeight) + #13 +
'lfWidth: ' + IntToStr(lfWidth) + #13 + { $R *.DFM }
'lfEscapement: ' +
IntToStr(lfEscapement) + #13 + procedure CallDDA(x, y: Integer; Form: TForm1);
'lfOrientation: ' + begin
IntToStr(lfOrientation) + #13 + if x mod 13 = 0 then
'lfWeight: ' + IntToStr(lfWeight) + #13 + Form.ImageList1.Draw(Form.Canvas, x, y, 0);
'lfItalic: ' + IntToStr(lfItalic) + #13 + end;
'lfUnderline: ' +
IntToStr(lfUnderline) + #13 + procedure TForm1.FormPaint(Sender: TObject);
'lfStrikeOut: ' + begin
IntToStr(lfStrikeOut) + #13 + LineDDA(0, 0, ClientWidth, ClientHeight,
'lfCharSet: ' + IntToStr(lfCharSet) + #13 + @CallDDA, Integer(Self));
'lfOutPrecision: ' + end;
IntToStr(lfOutPrecision) + #13 +
'lfClipPrecision: ' + procedure TForm1.FormResize(Sender: TObject);
IntToStr(lfClipPrecision) + #13 + begin
'lfQuality: ' + IntToStr(lfQuality) + #13 + Invalidate;
'lfPitchAndFamily: ' + end;
IntToStr(lfPitchAndFamily) + #13 +
'lfFaceName: ' + string(lfFaceName)); Figure 14: Code to draw a line of bitmaps.
end;
with CreateFontIndirect. Before using this new font, it must be selected
Figure 12: Getting and displaying font attributes. with SelectObject. Another way is to assign the handle of this new
font to the handle of the canvas’ font, before drawing the text. After
member, a number between 0 and 1000. 400 is normal text, values drawing the text, this work must be reversed; the old font must be
above this draw bold text, and values below it draw light text. selected, and the new font deleted. If the new font isn’t deleted, there
will be a memory leak, and — if the routine is executed many times
The code in Figure 10 draws text at angles ranging from 0 degrees — Windows (especially 95/98) will run out of resources, and crash.
to 360 degrees, at 20-degree intervals. It’s the form’s OnPaint event
handler, so the text is redrawn each time the form is painted. Figure Stylish Lines
11 shows the result. When you draw lines, the individual pixels usually don’t matter; you
simply set the line style, and it’s drawn by Windows. Sometimes
The form’s font is set to Arial, a TrueType font. This code works only however, you need to do something special and draw a line style
with TrueType fonts; other kinds of fonts don’t support text rotation. not provided by Windows. This can be done using a Windows API
To get current font settings and fill the TLogFont structure, you must function named LineDDA, defined in Figure 13.
use the GetObject API function. The code in Figure 12 shows how to
fill and display the TLogFont settings for the form’s font. The first four parameters are the starting and ending points of the
line. The fifth parameter is a callback function that will be called
Once you have the settings in a TLogFont structure, the only change every time a pixel should be drawn. You put your drawing routines
left is to set lfEscapement to the desired angle and create a new font there. The last parameter is a user parameter that will be passed to

At Your Fingertips
Figure 15: Window with a custom line.
the callback function. You can pass any Integer or pointer to the
function, because it is an LParam (in Win32, it is translated to a
Longint). The callback function must take the form shown here:
procedure CallBackDDA(x, y: Integer;

UserParam: LParam); stdcall;
where x and y are the coordinates of the drawn point, and UserParam
is a parameter that is passed to the function. This function must be
declared as stdcall. The routine in Figure 14 draws a line of bitmaps,
and Figure 15 shows the result.
This routine handles the form’s OnPaint event, calling LineDDA, so

every time the form must be painted, it redraws the line. Another
event that is handled is OnResize, which invalidates the form client
area, so the line must be redrawn when someone changes its size.
The LineDDA callback function, CallDDA, is very simple. At every
13th point it is called, it draws the bitmap stored in the ImageList.
As you may notice, Self is passed as the last parameter to the
callback function, so it can access the instance data.
Conclusion
Since owner drawing was exposed in TMainMenu in Delphi 4, there
have been many ways to augment your menus. Using the techniques
we’ve discussed here, you can easily enhance your Delphi application’s
menus with custom text, bitmaps, and colors. ∆
The files referenced in this article are available on the Delphi Informant
Magazine Complete Works CD in INFORM\00\DEC\DI200012BS.
A Brazilian, Bruno Sonnino has been developing with Delphi since its first
version in 1995. He has written the books 365 Delphi Tips and Developing
Applications in Delphi 5, published in Portuguese. He can be reached at
[email protected].

Case Study
By Denis Perrotti
ASSESS
Delphi Helps American Skandia Compete
A merican Skandia is a relative newcomer in the world of financial services. Nevertheless,

Iin a few years it has risen to become the number-one provider of independently sold,
variable annuities in the nation. It also owns the fastest growing mutual fund complex,
the American Skandia Advisor Funds. We’ve achieved that success despite the fact that we
don’t market directly to the public, or employ a captive sales force.
The lack of a captive sales force is key. We sell The Issues

only through independent financial professionals Originally, ASSESS consisted of only two programs
who can sell anyone’s products. To counter that, (the current total is 14) that supported only one
American Skandia offers exceptional products and product line: variable annuities. At that time it
provides a range of services that offer extra value to was programmed in Microsoft Visual Basic, which
the brokers who sell those products. ASSESS® is a served us quite well. Then the company began to
cornerstone of that value-added strategy. expand into other lines of financial products, includ-
ing qualified plans, mutual funds, and variable life
The Low-Down on ASSESS insurance. The challenge was clear: The program-
ASSESS is a suite of programs designed to assist ming team (which consisted of two people at the
financial professionals with every aspect of the time!) was going to have to support each of those
sales process. The programs can track clients and new product lines on ridiculously short deadlines.
their personal data, present information about the
individual portfolios offered for investment in our About that same time, we needed to move away from
products, and help the financial professional com- the standard Windows look to something more rep-
plete applications and other paperwork. resentative of American Skandia. The design depart-
ment set to work to create that look and was given
There’s even a multimedia program packed with total creative control. So they wouldn’t impose limits
information about American Skandia and its on themselves, they were told to assume we could
products, as well as general information about do anything, do it tomorrow, and do it for no
investing — including more than 400MB of money. The design they came up with was visually
videos and presentations. Today, ASSESS is dis- appealing and decidedly non-standard. This was the
tributed to more than 10,000 financial profes- look American Skandia was to build.
sionals each quarter, and has won wide praise
and recognition, including an award for top Finally, since our installed base was about to
CD-ROM in the industry in 1998. expand tremendously, ASSESS needed to be easily
deployable. We ran into numerous problems with
the Visual Basic deployment, including the usual
trips into DLL hell, with occasional detours into
VBX purgatory. It was an experience we were anx-
ious not to repeat.
Given these conditions, it was easy to see that

Visual Basic couldn’t meet our needs. Because
many of the programs were going to be similar
in nature, design, and structure, the development
tool needed to be fully object-oriented to make the
best use and re-use of code. Because we needed
to create a whole new look from scratch, our new
development tool needed to give us the ability to
quickly and easily create new controls and compo-

Case Study
nents. Finally, since our new look required extensive palette manipu- little work, and
lation given the custom color scheme, our new tool needed to be this was in
powerful and provide full access to the Windows API. 1997. Visual
Basic wouldn’t
Delphi to the Rescue have the ability
It didn’t take long to see that Delphi to create con-
was the only tool available that trols for some
American Skandia is a lead-
would meet all of our needs. It time, and —
ing marketer of variable
was fully object-oriented, with a even today —
annuities and mutual funds.
well-defined and remarkably flexi- control creation
ASSESS is a proprietary soft-
ble object model. Only Java, which in Visual Basic
ware product designed to
didn’t exist at the time, exceeds the isn’t in the same
assist financial professionals
Delphi object model in terms of league with
in the sale of those and other
flexibility and power. Also, Delphi’s Delphi. We
financial products. It’s built
visual environment was — and still were also able to include advanced GUI features in our controls and
on a custom architecture that
is — second to none. Delphi’s abil- programs, like pop-up buttons and mouse-overs. Such things may be
allows for rapid development
ity to produce true, stand-alone exe- common today, but they weren’t three years ago.
and customization.
cutables was also highly desirable.
Third-party tools: Delphi,
Because we don’t control our users’ The Aftermath
machines, the fewer dependencies Delphi has served us well for the better part of three years. Despite
Wise Installation System,
we have to worry about, the better. ever-changing requirements and our company’s “We need it now”
TCompress
There are none with Delphi. attitude, we have continued to deliver ASSESS on time and on
budget every quarter, while launching three new product lines, and
American Skandia
The ease with which we could the dozen new programs that support them. I can’t imagine another
One Corporate Drive
create entirely new visual and non- tool that would have allowed us to do that. ∆
Tower One
visual components sealed the deal
Shelton, CT, 06484
for Delphi. We created more than
Phone: 1-800-SKANDIA Denis M. Perrotti is Senior Programmer for E-Marketing, American Skandia Market-
two dozen brand-new, customized,
Web Site: http://www. ing, Inc., based in Shelton, CT. He can be reached at [email protected].
and highly stylized controls for
AmericanSkandia.com
use in ASSESS with remarkably

New & Used
By Bill Todd
LEADTOOLS Raster Imaging 12

A Toolkit with Intense Imaging Power
I f you need a powerful professional imaging toolkit that you can use as the foundation
for any graphics application, look no further than LEADTOOLS Raster Imaging 12 from
LEAD Technologies, Inc. LEADTOOLS includes support for more than 60 graphics file
formats, including JPEG, GIF, TIFF (including G3/G4, LZW, CMYK, and JTIF), PNG, BMP,
MODCA/IOCA, PCX, and TGA.
You can manipulate all or part of an image using the document imaging product, the royalty varies
more than 70 digital filters and transforms, includ- from US$75 per unit for quantities less than 50, to
ing smooth; sharpen; edge detect and enhance; US$1.50 per unit for quantities of 10,000 or more.
change brightness, contrast, and gamma; change hue
and saturation; add noise; resize and rotate images; Although all of the functionality of LEADTOOLS
and change color depth. All standard image com- is implemented in a collection of DLLs, you have
pression techniques, including JPEG, CMP, LZW, your choice of two high-level interfaces to make
G3/G4, Huffman, and run-length, are available, programming your graphics application easier. If
as is LEADTOOLS’ high-performance proprietary you’re working in Delphi or C++Builder, you’ll
compression algorithm. You can also apply 2,000 want to use the VCL components. For other lan-
display effects to modify the appearance of an image. guages, use the ActiveX control.
The LEADTOOLS Family Components

The first challenge you’ll face when evaluating LEAD- The main VCL component is the LeadImage con-
TOOLS is deciding which product you need. The trol. This visual component lets you load images
LEADTOOLS family consists of nine products: from a file, the Internet, or memory, display the
§ Raster Imaging image on a form, and apply any of the vast col-
§ Raster Imaging Pro lection of filters or effects that LEADTOOLS pro-
§ Multimedia vides. You can scale the image to fit the control or
§ Multimedia Pro view the image full size. If the image doesn’t fit in
§ Vector Imaging Pro the LeadImage component, you can display a pan
§ Document Imaging window. The pan window, shown in Figure 1, is
§ Document Imaging Pro a thumbnail with a red rectangle that outlines the
§ Medical Imaging visible area of the image. Simply drag within the
§ Medical Imaging Pro thumbnail to reposition the visible area. It’s much
easier than using scrollbars to move around. Figure
For help choosing the right product, go to 2 shows the same flower scaled to fit the LeadIm-
the LEAD Technologies Web site at http:// age control, flipped, darkened, and with its hue
www.leadtools.com, click on Products, then click on adjusted to add more green.
Comparison Chart to see which features are included
in each product. Note that although the Raster LEADTOOLS includes a LeadTwain component,
Imaging and Multimedia products don’t require which lets you acquire images from any TWAIN
a royalty on each copy of your software, the device, such as a scanner or digital camera. You
document, medical, and vector imaging products can display the device’s user interface to let users
do. Even if you purchase distribution licenses in set the acquisition parameters, or hide the device’s
advance, you must file periodic reports with LEAD- built-in interface and design your own, passing all
TOOLS indicating the number of copies deployed settings to the device through properties of the
both within your organization and to outside users, LeadImage component. The LeadIsis control pro-
unless you purchase a perpetual unlimited deploy- vides the same image acquisition features for ISIS
ment license. Royalty amounts vary based on the devices, but only functions if you have one of the
number of units shipped. For example, if you use document or medical versions of LEADTOOLS.

New & Used
If you need to provide screen-capture capabilities in your application, include everything from colors to whether the text associated with the
simply drop a LeadScr component on a form, and you’re ready to image is displayed with the image. A set of events, including OnClick,
go. This component lets you capture the full screen, active window, OnDblClick, OnItemSelected, OnResize, OnScroll, and the mouse and
active client area, menu under the mouse cursor, window under the keyboard events inherited from TWinControl, make it easy for you to let
mouse cursor, selected object, mouse cursor, or desktop wallpaper. If the user interact with the images in the image list in any way you wish.
these standard screen objects don’t meet your needs, you can capture
any area of the screen by specifying the size and location of one of To make it easy for users to select images from files, use the thumb-
eight standard shapes, or by letting the user make a freehand selection nail browser component. This component scans a directory and
of the area to capture. You can also capture cursor, icon, and bitmap generates a thumbnail image for every image file in the directory.
resources from 16- and 32-bit DLL and EXE files. The last component on the LEADTOOLS palette is the DICOM
component, which provides DICOM file support if you have one of
The image common dialog box component provides a series of dialog the medical imaging products.
boxes similar to the Windows common dialog boxes, but with added
imaging features. It provides dialog boxes for File Open, File Save, all Documentation
of the image processing options, and all of the image effects. The File Although LEADTOOLS is a technically excellent toolkit and claims
Open dialog box provides a thumbnail preview of the image in the to be the world leader with an impressive list of users (including
selected file. All of the image processing and effects dialog boxes provide Microsoft, Hewlett-Packard, and Corel, to name a few), the docu-
a thumbnail preview that lets you see the effect before you apply it to mentation leaves something to be desired. The only printed docu-
your image. An optional Help button is also available in each dialog box, mentation is a small manual that provides six pages of installation
so you can easily integrate context-sensitive help for all of the features. instructions and 69 pages of marketing information about the LEAD-
TOOLS product line. Online documentation includes a 993-page
The image list component lets you display and manipulate a list of manual in PDF format, and a help file that contains the same infor-
images. You can think of the image list component as a visual TList mation. You can purchase the manual in printed form if you wish.
for images. Methods let you load images from, and save images to
files, insert images, remove images, and clear the entire list. A host You would think that with this volume of information, everything you
of properties let you control how the items in the list appear. These need to know would be there — but I didn’t find that to be the case.
The manual is very long on topics that tell you what LEADTOOLS can
do, and very short on topics that tell you how to do it. For example, if
you search the manual for Screen Capture, you will find a section titled
“Implementing Screen Capture.” However, the only information in that
section is a description of what the screen capture component can do.
There is not one word about how to do it, nor is there any reference to
any other topic that describes how to capture screens.
Delphi and C++Builder developers are used to going to the help index,
entering a class name, and being taken to a topic that provides a descrip-
tion of the class and a list of all of the properties, methods, and events
for the class with each property, method, and event providing a link
to its own topic. If you search either the LEADTOOLS online help
or the manual for a component class name, such as TLeadImage, you
will find nothing. There is no way to find a topic that will give you a
list of the properties, methods, and events of any of the LEADTOOLS
components. If you know the name of a property, method, or event, you
Figure 1: The LeadImage control with a pan window displayed. can find its help topic, but the only way to find the names is to use the
LEADTOOLS 12 is an excellent graphics toolkit you can use as the

foundation for any application that needs to acquire, manipulate,
display, or print images in any common format. Although the docu-
mentation shortcomings of LEADTOOLS 12 make learning to use it
more difficult than it needs to be, this is still a superior product that
you should seriously consider.
Lead Technologies, Inc.

900 Baxter Street
Charlotte, NC 28204
Phone: (800) 637-4699 or (704) 332-5532

Web Site: http://www.leadtools.com
Price: US$495
Figure 2: An image with altered hue and brightness.

New & Used
Object Inspector for published properties and events; read the overview demonstration application are available for Delphi 4 and 5 and for
chapters of the manual, which list some of the properties, methods, and C++Builder 4 and 5. Unfortunately, there are problems here as well.
events; and browse the tutorial code and sample application. When you run the Delphi 5 version of the demonstration and choose
File | Browse from the menu, all you get is an error dialog box with
There is a tutorial chapter for Delphi developers, and another for the message “GetDirectory: invalid parameter passed.”
C++Builder developers, that steps you through building programs
that demonstrate many of the features of LEADTOOLS. These chap- Conclusion
ters are a very valuable resource, but even here there are problems. LEADTOOLS is an excellent graphics toolkit that you can use as
the foundation for any application that needs to acquire, manipulate,
Suppose you want to acquire an image from a TWAIN scanner. You display, or print images in any common format. You cannot have this
can go to the section in the Delphi tutorial titled “Creating a TWAIN much power without complexity and, as a result, the LEADTOOLS
Project.” This tutorial consists of eight steps that tell you to drop a components include a very large number of properties, methods,
LeadImage and a LeadTwain component on the main form, add four and events that you’ll need to master. Although the documentation
lines of code to the form’s OnShow event handler to set the values of shortcomings make learning to use the toolkit more difficult than it
four properties, run the program to test it, and save the project as the needs to be, this is still a superior product that you should seriously
starting point for other tasks in the tutorial. Testing the application consider if you need to do high-end image processing. ∆
seems kind of silly because it’s obvious that the only thing it will
do is display a blank form. A natural step would be to move on
to the next section to learn how to actually acquire an image from
a TWAIN device. Whoops! The next section in the tutorial is on
creating, viewing, and merging color separations. Now what? Let’s go Bill Todd is president of The Database Group, Inc., a database consulting and develop-
back to the table of contents and find the next section in the tutorial ment firm based near Phoenix. He is co-author of four database programming books,
that deals with TWAIN. Whoops! There are no other sections that author of more than 60 articles, a Contributing Editor to Delphi Informant Magazine,
mention the word TWAIN. Fortunately, because the manual is in and a member of Team Borland, providing technical support on the Borland Internet
PDF format, you can do a global search for TWAIN and eventually, newsgroups. He is a frequent speaker at Borland Developer Conferences in the US and
you’ll find that the rest of the TWAIN example is buried in the section Europe. Bill is also a nationally known trainer and has taught Delphi programming
named “Miscellaneous Examples” at the end of the tutorial chapter. classes across the country and overseas. He is currently a speaker on the Delphi Develop-
ment Seminars Kylix World Tour. Bill can be reached at [email protected]. For more
There is also an extensive demonstration application that shows information on the Kylix World Tour, visit http://www.DelphiDevelopmentSeminars.com.
how to use most of the features of LEADTOOLS. Versions of the

TextFile
Wireless Web Development

Interest in wireless application development ous wireless infrastructures, protocols, and
is exploding. Nearly every major portal, con- markup languages available for the various
tent provider, and eBusiness site is evolving wireless and offline clients. Ray summarizes
some form of wireless support for their ser- in efficient prose some of the more com-
vices. Given the current state of health in mercially visible markup variants, including
the wireless communications market, it’s not Palm’s Web Clipping Architecture, Avant-
surprising, especially since this is the first Go’s channel service, Microsoft’s Channel
time in history that so much information can Definition Format for mobile devices
be obtained through such a small, portable (i.e. Windows CE/Pocket PC clients),
communications device. Phone.com’s Handheld Device Markup
Language (HDML), and WAP Forum’s
Naturally, the servers providing content to Wireless Markup Language (WML). Addi-
desktop browsers have to be instructed how tionally, Ray devotes a chapter to the
to handle this new era of mobile information emerging, but sparsely implemented,
interaction. And like the amazing effort that WMLScripting client-side language that’s
went into the construction of the Internet, beginning to show up in high-end WAP-
many hard working developers will have to enabled mobile devices.
rise to the challenge and expend the mental
effort to understand, practice, and instruct I also enjoyed Ray’s conversational writing
others in wireless application development style. Although this book is intended for see examples in ASP, JSP, CFML, and Perl/
best practices. techies, Ray keeps the tone light and general CGI, which are more prevalent technologies
enough for an average reader to finish the from an ISP-hosting point of view. Addi-
To that end, Ray Rischpater provides a book in a day. As indicated earlier, however, tionally, there are many more books pub-
primer to the wide world of the wireless Web this generalization of the subject matter also lished on these languages than there are on
in his Wireless Web Development. Although detracts from the book’s value. PHP. At the very least, I would have pre-
the primary intended audience is existing ferred to see an area dedicated to source
Web professionals, Ray’s coverage of topics Unfortunately, my list of negative aspects variants on Apress’ Web site along with the
run the gamut from the rudiments of regarding Wireless Web Development exceeds book’s printed code listings.
HTML to specific server-side scripting tech- its praises. I’m fairly adept at wireless applica-
nologies such as the open-sourced PHP lan- tion development, which is one of the rea- On the topic of references, I was also
guage. Given that the book is only 350 sons I was asked to review this title. This disappointed that Ray omitted a list of
pages, covering such a broad spectrum of background altered my expectations; I was free tools and services available to wireless
information is tricky. And while Ray’s mad anticipating a much deeper discussion of Web developers. In my own exploration,
dash through the various flavors of both pro- wireless Web development. I found Inetis’ DotWAP (available at
prietary and open wireless standards is com- http://www.inetis.com/english/
mendable, the usefulness of the book to the The book blazes through dynamic server- solutions_dotwap.htm) to be a great
trained Web professional is diluted and less side scripting, and the author exhibits a time saver when generating basic WML
valuable as a result. bias toward PHP as the server script of cards. Additionally, WAPJAG (http://
choice. Granted, this free, cross-platform, www.wapjag.com) provides a free
On the positive side, Wireless Web Devel- open source technology is a worthwhile Phone.com-like WML-compliant client
opment provides a fairly comprehensive, contender in dynamic wireless content gen- to view a broad range of Internet-
albeit slightly dated, summary of the vari- eration, but I would have preferred to also accessible WML content. Lastly, I really

TextFile
like Chami’s excellent and free HTML-Kit (available at stands, developers expecting to use the title as a reference will find
http://download.cnet.com/downloads/0-10070-100- it frustrating to have to leaf through chapter pages to locate a single
1507274.html?tag=st.dl.10001_103_1.lst.td), which offers a com- tag’s meaning.
mercial-grade Web scripting editor with full support for nearly every
major server and client-side Web language, including Ray’s prefer- As with most titles written by working professionals today, it’s obvi-
ence, PHP. Given that the book doesn’t include a CD-ROM, the ous that the author spent many evenings and weekends of his valu-
least it could provide is a more comprehensive list of tool resources. able time to put into words his understanding of the subject matter.
I have no doubt that Ray is a talented Web developer who struggled
Another unfortunate omission — one that would have been highly with what to discuss and what to leave out. On a positive note, I was
beneficial as an appendix — is resolving the aggravating question quite pleased that Ray’s book is one of the few general Web develop-
of how a wireless Web developer can effectively support the many ment books that intelligently advocates the use of Unified Modeling
flavors of client-side scripts and presentation layers introduced in Language (UML). All of the sample program flows are illustrated
the book. As it stands, an untrained developer might approach throughout the book in easy to understand UML diagrams, and Ray
the problem by manually creating multiple site sections for each even dedicates a full appendix to the language. Regrettably, there
platform the developer wishes to support. Instead, even a cursory simply aren’t enough of these appendices in the book to make it a
introduction to an effectively designed n-tier architecture separating regular reference for wireless Web developers.
data, business, and presentation logic would have communicated a
simple, yet powerful message: A well-designed foundation is crucial — Mike Riley
to the success of any Web site’s scalability and support for the ever-
evolving wireless Web. Wireless Web Development by Ray Rischpater, Apress, 901 Grayson
St., Berkeley, CA 94710-2617, http://www.apress.com.
Finally, continuing the discussion of omissions, I would have pre-
ferred to see a keyword summary listing in separate appendices for ISBN: 1-893115-20-8
each of the scripting technologies introduced in the book. As it Price: US$34.95 (350 pages)

TextFile
Advanced Delphi Developer’s Guide to ADO

When I met Dr Natalia Elmanova (one of ponents: TADOTable, TADOQuery, and
the authors) at last summer’s Inprise/Borland TADOStoredProc. No database book would
Conference, she asked me immediately if I be complete without a chapter on SQL,
would review this book. I didn’t know of it and Advanced Delphi Developer’s Guide to
at the time, so I gave her a tentative “yes.” ADO includes a fine one. The first half of
I should mention that I am quite selective the book ends with two chapters, “Working
about the books and products I review; I with Database Objects” and “Building Data-
don’t enjoy slamming a work, or wasting base Applications.”
my time for that matter. When my copy of
Advanced Delphi Developer’s Guide to ADO Exploring advanced ADO topics. Having laid
arrived, I realized I had no choice; I had to a solid foundation in the first half, the second
review this book. Let’s find out why. half explores more advanced topics, such as
working with business graphics, reports, and
Providing a solid background for working analysis systems using ADO and Delphi com-
with ADO. The first observation I made ponents. Unfortunately, not every aspect of,
while reading the opening chapters was this: or extension to, ADO is covered by Delphi
The authors, Dr Elmanova and Alex Fedorov, components; the authors address this issue in
were real educators. Not only do they have a some of the remaining chapters. Chapter 15
solid grasp of the subject matter, they’re able and those that follow are longer and introduce
to present it in a very clear manner. To their more difficult topics. Chapter 15, for exam- Another thing you’ll need to do is un-check
credit, they leave nothing to chance, making ple, shows how to use type libraries to access the Build with Run-time packages check box in
few assumptions about the potential reader’s ADO MD (multidimensional) objects. Chap- the Project Options dialog box. You’ll probably
level of knowledge or experience. I concur ter 16 explains ADO DLL and security exten- already have an appropriate database installed
with them that this book will be accessible sions; Chapter 17 covers Microsoft’s Jet and on your system; if not, you’ll need to take
and valuable to those “programmers who are Replication library; and Chapter 18 explains care of that as well. Some good news: An
already familiar with Delphi, but are novices the somewhat complicated issues of deploying updated version of the code is available already
in using ADO.” In fact, the book assumes ADO applications built with Delphi. at http://d5ado.homepage.com.
little or no knowledge about database pro-
gramming, and devotes the opening chapter The remaining chapters deal mostly with To conclude, this is a most impressive work
to one of the most cogent introductions to issues surrounding distributed applications — an excellent, well organized, and well writ-
this topic I have ever seen. using Microsoft’s Remote Data service, Bor- ten treatise. The authors assume nothing in
land’s MIDAS, and the Microsoft Transaction terms of the reader’s background in database
As you may know, ADO (Microsoft ActiveX Server. The final chapter introduces the latest programming or ADO. They provide you
Data Objects) is one of several technologies version of ADO (2.5), which is an integral part with all of the background information you
that enable universal data access. Fortunately of Windows 2000. Before closing, I should might require, and build on that foundation
for us, it’s a technology that Delphi supports. point out an area or two of weakness and alert by providing an excellent exposition of ADO,
In the second chapter, the authors discuss you to some issues in running the code. including some important advanced topics.
ADO in its larger context, giving the reader an For any reader who will be creating Delphi
excellent overview of what is available. Chap- One area that could be improved: running applications that use this important technol-
ter 3 discusses another of these technologies, the code. The weaknesses in this book are ogy, I recommend this book highly. It’s an
OLE DB, and provides the first code exam- quite minimal. While the index is good, it essential resource.
ples. Chapter 4 returns to more basic issues, should be more detailed. For example, at
discussing the Delphi Database Architecture various places in the book, the authors make — Alan C. Moore, Ph.D.
and the components that support it. reference to Windows 2000, but there is no
reference to Windows 2000 in the index. Advanced Delphi Developer’s Guide to ADO
The next three chapters are devoted to by Natalia Elmanova, Ph.D. and Alex Fedo-
ADO, exploring the basic components Another area I should warn you about con- rov, Wordware Publishing, Inc.,
TADOConnection, TADOCommand, and cerns running the applications. Of course most 2320 Los Rios Blvd., Plano, TX 75074,
TADODataSet. The next chapter exposes readers who copy Delphi code from a CD to http://www.wordware.com.
three more ADO components that have par- their hard drive are already aware of the need
allels in Delphi’s standard database com- to change the read-only property of those files. ISBN: 1-55622-758-2

Best Practices
Directions / Commentary
All Developers Are in R&D
A ll developers are in R&D — or should be. Personal research (books, magazines, newsgroups, Web sites, and source
lcode) and development (hacking and side projects) are necessary if you’re to grow as a developer and adapt
to changing needs. In contrast, developers who concentrate only on their assigned tasks often harm themselves and
their employers.
It’s self-defeating to subscribe to the “begin coding as soon as tion from scratch, using the preferred method. I finished in approxi-
possible to finish the project as soon as possible” mindset. It’s mately 15 minutes. Yes, what you don’t know can come back to
specious reasoning. Although it sounds sensible on the surface, chomp you on the gluteus maximus!
it often leads to chaos and project cancellation. It’s the same as
thinking that devoting all your time to a project (and thereby When you get a new version of Delphi, do you simply kick the tires
neglecting research and development) is selfless and valorous. and take it for a spin, or do you also look under the hood? As Danny
Such self-sacrifice is deleterious to you and your employer or Thorpe said: “Use the source, Luke!” Read it. Seek out the changes
client. Not opening up to better ways means you’re not doing from the last version. What do the new components do? What classes
your best work. have been added that don’t show up on the Component palette? What
functions are new to this version? It would be a shame to rewrite code
Failing to aerate the brain and rejuvenate the creative juices that has already been written, tested, and debugged for you. In Delphi
leads to an atrophy of spirit and an inbreeding of thought. To 6 take a look at the new declaration of TComponent, the new utilities
quote Charlie Calvert on the importance of hacking from Delphi in the Math unit, new units such as StrUtils, ConvUtils, DateUtils,
Unleashed: “Most good programmers spend a large percentage of VarUtils, Bands, etc. Check out the IfThen, AnsiIndexText, Soundex,
their time hacking. If you run a programming shop and you and Metaphone functions. You won’t know they’re available if you don’t
arrange things so that none of your programmers have time to look for them. Be curious; become a Delphi expert!
hack, you will end up with a group of very mediocre program-
mers. The best will either lose their skills, or more likely, head Expand your knowledge: Pick your colleagues’ brains, explore, and
for greener pastures.” experiment. Reading, sharing with others, and scouring OPC (other
people’s code), should give you countless ideas for utilities. Side
If we rely only on personal prior knowledge (been there, done that) projects and hacking, and using technology or components differ-
and hard work (I don’t have time to stop and sharpen the saw, I’ll just ent from your usual group will expand your horizons. Write a
work harder/faster), we are limiting our productivity. database application using a different DBMS and/or engine. Write
components that answer tricky programming challenges or Delphi
What you don’t know can hurt you. An example of this is my FAQs, so you can say: “Just use this component; the functionality
first program in Delphi 1. Its sole purpose was to return the day you’re after is automatically provided.” The possibilities for personal
of the week for a date entered by the user. I labored over this advancement and self-expression are virtually endless. Grab them
little application, and wrote so much complex code, that I got before they grab you. Innovate or stagnate! ∆
a run-time error for using up too much stack space. Finally, the
happy moment came when the code was broken up into smaller — Clay Shannon
methods, the stack space was increased, and the program was
debugged. It worked like a charm. No papa was prouder as I Clay Shannon is an independent Delphi consultant based in northern Idaho. He is
showed off my baby. available for Delphi consulting work in the greater Spokane/Coeur d’Alene areas,
remote development (no job too small!), and short-term or part-time assignments
Not much later, though, I discovered the standard Delphi DayOfWeek in other locales. Clay is a certified Delphi 5 developer, and is the author of Develop-
function. I could have saved myself hours using this function and er’s Guide to Delphi Troubleshooting [Wordware, 1999]. You can reach him at
writing just one line of code! To punish myself I re-wrote the applica- [email protected].

File | New
Directions / Commentary
The Delphi Toolbox: In the Bin
I iwrote the first in this series of columns a year or so ago to concentrate on third-party tools, components, and libraries,
iproviding mini reviews along with tips and techniques. Recently I realized that there are a number of hidden gems —
useful but little-known utilities — that come with Delphi. All of these can be found in the Delphi\Bin folder, and many
go back to early versions of Turbo Pascal.
Command-line utilities. To learn the syntax and options for com- TDump.exe is well named. This utility will literally dump a ton
mand-line utilities, you can usually either type the name alone, or the of information about an executable file to the screen. It lists the
name with a question mark (?) at the command prompt. One of the DOS file size, load-image size, header size, minimum and maximum
veterans of Turbo Pascal is TPC.EXE, the command-line compiler, memory requirement, program entry point, CPU type, O/S version,
with its new name DCC32.EXE. Its long list of available switches various flags and offsets, code and data sizes, and base locations. It
provides you with the many compilation options available in the provides information about exports and imports, resources, object
Delphi IDE. You may be wondering, “Why use such a cumbersome tables, imports from Windows DLLs, and much more.
tool when you have the IDE available and can simply click with the
mouse?” In the old days, one motivation was memory — more was One final command-line tool might be helpful in certain circum-
available at the command prompt than in an IDE. That’s not such an stances. Convert.exe provides a quick and easy way to convert one
issue in compiling large programs today. Another reason for using this or more Delphi form files to either text or binary formats. You
fast compiler is to automate compilation of multiple units in a batch have the option of converting the file in-place, overwriting the
or “make” file, a technique used by third parties when they distribute input file.
patches to their libraries.
Wizards. In addition to the command-line tools we’ve been dis-
Let’s make it. Another venerable utility, MAKE.EXE, is a program cussing, there are many useful Wizards in the \Bin subdirectory.
manager for compiling programs with specific options. Those options Some are integrated into the Delphi IDE; others can be easily
are listed in a text file that generally has a *.mak extension. added to the Tools menu. There are several tools for managing
databases (not available in all editions), including the BDE Admin-
Make files, which are similar to batch files, can be used to automate many istrator, which lets you configure the Borland Database Engine
processes: from building large complex projects, to compiling resource (BDE) among other tasks; Database Explorer, for browsing and
files. Delphi comes with a large make file called, of all things, Makefile! editing database objects; and tools for working with SQL. The
If you have Turbo Assembler and other required files, you can run this Image Editor is a useful tool that provides an easy way to work
with a recent version of MAKE.EXE to rebuild the entire VCL from with graphic files you use in your applications, e.g. icons, cursors,
the command line. You can also edit the file to create either a debug or and bitmaps. Finally, WinSight is a debugging tool that provides
non-debug version of the library. On the command line you can specify information about window classes, windows, and messages. For
options (including the make file to use), and one or more target files. more information on these and other tools, look under Delphi
Productivity Tools in the Delphi Help file.
Other options include specifying whether to conduct auto-dependency
checks, providing the name of an include directory, and indicating Remember, before you go looking for a solution from a third-party
whether to ignore encountered errors. You can do a lot in the main source, check out what’s available with Delphi. You just might discover
make file, such as defining macros. These can serve as shortcuts to exe- the solution to your problem “in the bin.” Until next time... ∆
cutable files (usually compilers), including their full path and options.
You can also define explicit rules and implicit rules. Implicit rules are — Alan C. Moore, Ph.D.
generalizations of the explicit rules and help to simplify a make file.
Alan Moore is a Professor of Music at Kentucky State University, specializing in music
Get a grep or dump it. What’s this grep thing all about? Consider composition and music theory. He has been developing education-related applications
this scenario: Months ago you wrote a wonderful utility that with the Borland languages for more than 15 years. He is the author of The Tomes
accomplished its task perfectly, but now you’ve forgotten which of Delphi: Win 32 Multimedia API [Wordware Publishing, 2000] and co-author (with
programs it’s in. You do remember the name of the routine, so John Penman) of an upcoming book in the Tomes series on Communications APIs. He
it’s grep.exe to the rescue! This fast file-searching utility provides has also published a number of articles in various technical journals. Using Delphi, he
a plethora of options, including word search, regular expression specializes in writing custom components and implementing multimedia capabilities
search, inclusion or exclusion character set searches, and more. Best in applications, particularly sound and music. You can reach Alan on the Internet at
of all, it’s freely available with every version of Delphi. [email protected].

On The Cover: December 2000, Volume 6, Number 12

Uploaded by

Copyright:

Available Formats

On The Cover: December 2000, Volume 6, Number 12

Uploaded by

Document Information

Original Description:

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

On The Cover: December 2000, Volume 6, Number 12

Uploaded by

Copyright:

Available Formats

December 2000, Volume 6, Number 12

Cover Art By: Arthur Dugoni

I’ve Got a Secret

2 December 2000 Delphi Informant Magazine

Global Majic Announces 3DLinX

3 December 2000 Delphi Informant Magazine

Quest Announces Optional Module for TOAD

4 December 2000 Delphi Informant Magazine

4Tier Software Announces OpenMOM

5 December 2000 Delphi Informant Magazine

Inprise/Borland Announces JBuilder 4

6 December 2000 Delphi Informant Magazine

Implementing COM+ Events

One of the major characteristics of pre-COM+ A Hypothetical Retail Application

7 December 2000 Delphi Informant Magazine

Using an event-based approach, it’s easy to see that:

business component that listens in on the event, or even the

COM+ Event Infrastructure uses

8 December 2000 Delphi Informant Magazine

procedure TriggerEvent; procedure TOrder.PlaceOrder(

First, we’ll need to run the Component Services administration tool,

The next step is to install OrderEvents as an event class into applica-

9 December 2000 Delphi Informant Magazine

It’s important to point out that EMailer implements the IOrderEvents

unit EMailer; interface

procedure TEMailer.SendEMail; procedure TOrderLogger.LogOrder;

Figure 6: EMailer subscriber code. Figure 8: The OrderLogger unit.

10 December 2000 Delphi Informant Magazine

After installation, we then configure the event subscriptions. To

Figure 9: The OrderLogger definition in the Type Library editor.

Figure 12: Component Services after configuring the subscrip-

Figure 10: Installing EMailer and OrderLogger subscribers.

11 December 2000 Delphi Informant Magazine

Subscriber Filters Conclusion

To test the events, I’ve built a simple client application

procedure TForm1.ExecuteOrderClick(Sender: TObject);

Figure 15: Performing a purchase order transaction.

12 December 2000 Delphi Informant Magazine

New List Objects

The TList Class Anyone who’s used TList to maintain a list of

13 December 2000 Delphi Informant Magazine

TComponentList = class(TObjectList) TStack = class(TOrderedList)

14 December 2000 Delphi Informant Magazine

TObjectStack and TObjectQueue Classes

pointers and integers. (The IntList unit is available for download;

15 December 2000 Delphi Informant Magazine

begin inherited Items[Index] := AMyObject;

procedure TClassList.SetItems(Index: Integer;

Begin Listing Two — TMyObjectList end;

TMyObject = class(TObject) TObjectQueue = class(TQueue)

16 December 2000 Delphi Informant Magazine

function TMyObjectQueue.Pop: TMyObject; function TIntList.Last: Integer;

procedure TMyObjectQueue.Push(AMyObject: TMyObject); function TIntList.Remove(Item: Integer): Integer;

procedure TIntList.SetItem(Index: Integer;

function TIntList.Extract(Item: Integer): Integer;

17 December 2000 Delphi Informant Magazine

Two Office Web Components

18 December 2000 Delphi Informant Magazine