Delphi 3 Activex: A Handy Introduction

February 1998, Volume 4, Number 2
Cover Art By: Tom McKeith
Delphi 3 ActiveX
A Handy Introduction
ON THE COVER
5 Delphi 3 ActiveX Dan Miser
Just in case you don’t know, Delphi 3 is a major player in ActiveX devel-
opment. Mr Miser demonstrates many of Delphi 3’s capabilities in this
area, including: importing ActiveX controls, converting VCL controls into 27 On the Net
ActiveX controls, creating custom ActiveX controls, and more. Picture This on the Web Keith Wood
Mr Wood generates a CGI program with Delphi 3, using its new Web
module components to create a CGI program that delivers pictures
FEATURES from a database to a Web page.
11 Informant Spotlight
ActiveX Scripting Tom Stickle
With ActiveX scripting, developers finally have a platform for adding
standard scripting support to their applications. Mr Stickle shows us how REVIEWS
to employ the tool from Delphi 3. 33 Abbrevia and LockBox
Product Review by Alan Moore, Ph.D.
18 DBNavigator
Insightful Delphi Cary Jensen, Ph.D. 39 High Performance Delphi 3 Programming
So you think you know the Delphi Code Editor? Odds are you’ll be Book Review by Warren Rachele
pleasantly surprised by an item or two uncovered by Dr Jensen in this
in-depth examination of Delphi 3 Code Insight.
23 OP Tech DEPARTMENTS
What’s in the Package? Adam Chace
Its implementation of packages is another important aspect of Delphi 3. 2 Delphi Tools
Mr Chace describes them, puts them in perspective, and spotlights the 4 Newsline
development possibilities. 41 File | New by Alan Moore, Ph.D.
1 February 1998 Delphi Informant
SureHand Software Offers ViCiouS Pro
Delphi SureHand Software intro-
T O O L S duced ViCiouS Pro, a ver-
sion control system that
New Products enables recognition, cus-
and Solutions tomization, and creation of
logical file families. ViCiouS
Pro includes file family defi-
nitions for C++Builder,
Delphi projects, Delphi
forms, Paradox tables, and
dBASE tables.
Users have control over def-
initions for keyword expan-
sion on a per-file extension
basis, with the ability to
establish standard history
blocks for logging com-
ments. ViCiouS Pro also
supports keyword expansion
within incoming and outgo- directly with Delphi and ViCiouS Pro is available in
Blinkinc Ships Shrinker 3.2 ing files. C++Builder. Programmers 16- and 32-bit versions.
Blinkinc announced the ViCiouS Pro supports single- may also access the version
release of Shrinker 3.2, a utility or multiple-user environments. control features by using the SureHand Software
that compresses and transpar-
ently decompresses Windows One copy of common units Archive Explorer. The Admin Price: US$76 per user license, with
and real-mode DOS programs. and forms may be shared Tool provides facilities for discounts for multiple users.
Shrinker 3.2 compresses 16-
and 32-bit Windows programs between multiple projects. defining users, file families, Phone: (314) 963-1935
and resources, including EXEs, ViCiouS Pro integrates and keyword definitions. Web Site: http://www.surehand.com
DLLs, DPLs, OCXs, and ActiveX
controls. This version includes
support for long filenames and
Business Solutions Introduces Client/Server Version of Purchase Manager
an enhanced Windows user inter- Business Solutions, Inc. Complete Delphi source ture allows conversion to
face. Shrinker 3.2 supports
Windows 3.1, Windows 95,
announced Purchase code, implementation assis- any BDE-supported data-
Windows 98, and Windows NT Manager 2.0, a client/serv- tance, and consulting are base.
3.51 and 4.0. er version of the company’s also available. The source
Any EXE, DLL, DPL, or OCX
compressed with Shrinker will purchasing management code version includes the Business Solutions, Inc.
transparently decompress itself system. Written in Delphi, BSI Guardian Application Price: US$10,000, plus US$500
into memory at run time. By
reducing the amount of data it runs against the Oracle Security System, also writ- per user; additional US$10,000 for
transmitted, and decompressing database, and serves medi- ten in Delphi. Although source code.
the program on the local work- um to large organizations. Purchase Manager is writ- Phone: (218) 384-4210
station at run time, Shrinker
minimizes LAN, WAN, and Purchase Manager handles ten for Oracle, its architec- Web Site: http://www.bsi-net.com
Internet traffic. regular and quick
For pricing and information, call
(804) 784-2087or visit requisitions, pur-
http://www.blinkinc.com. chase orders, con-
tract orders and
releases, RFQ bid-
ding, and shipment
orders for raw
materials, spare
parts, and services.
It also includes a
comprehensive
inventory manage-
ment system, and
easily interfaces
with existing
accounts payable
and financial sys-
tems.

Delphi Quality Software Components Releases GP-Version 3.5
Quality Software
T O O L S Components, Ltd.
released GP-Version
New Products 3.5, a change control
and Solutions system for Delphi and
C++Builder. This ver-
sion includes user-
defined file groupings,
which allows users to
define files that should
be archived as a single
entity and specify
what file types are
dependent on others.
With Delphi, GP-
Version recognizes
which files must
remain writeable when the 32-bit GP-Version is ality to any file-based appli-
checked in. defined in a single .DLL, cation.
GP-Version also allows and doesn’t require any
users to define multiple third-party tools. An API Quality Software
EFD Announces
HyperString 2.0 for Delphi
configurations, allowing a defined into this .DLL is Components, Ltd.
EFD Systems announced different set-up for each available upon request. This Price: US$125 per user
HyperString 2.0, a comprehen- client. allows developers to add E-Mail: [email protected]
sive library of string functions The entire functionality of version control function- Web Site: http://www.qsc.u-net.com
designed for Delphi’s 32-bit
dynamic string type.
HyperString offers over 200
Skyline Tools Releases ImageLib Corporate Suite 3.0
functions, both high- and low- Skyline Tools announced desktop, database, Internet, lighting, “paste its” (sticky
level, with many coded in hand-
optimized assembler. All functions version 3.0 of ImageLib and multimedia applications. notes), labels, arrows, notes,
are documented in WinHelp for- Corporate Suite, a document The suite supports JPEG, polygons, circles, and squares.
mat for integration into the imaging development package GIF, PNG, PCX, BMP, The zoom, scroll, and pan fea-
Delphi online Help system, pro-
viding access during coding. that features over 40 image Baseline TIFF, TIFF3/CITT, tures offer control when mov-
Included in the HyperString manipulation and correction TIFF4/CITT, multi-page ing across enlarged images.
function set are the usual array tools. TIFF, TIFF Packbits, TIFF Version 3.0 includes a
of search and edit routines,
along with hashing, encryption, The ImageLib Corporate LZW, Kodak Photo-CD, TWAIN Manager, which
compression, fuzzy-matching, Suite is compatible with TGA, DFX, ICO, EPS, and scans and stores images in a
numeric expression evaluation, Delphi, C++Builder, Borland other formats. multi-page TIFF in one step,
and a unique implementation of
dynamic arrays using dynamic C++, Microsoft Visual C++, The suite offers OCR fea- and supports all TWAIN-
strings as containers. Token rou- Visual Basic, and others, tures, as well as image-annota- compliant digital cameras.
tines provide parsing of allowing developers to create tion capabilities, such as high- In addition, the suite
HTML/XML strings, and support
the creation of hierarchical data includes the Thumbnail Image
structures inside strings. Manager and point-and-click
For more information visit image-correction effects, such
http://efd.home.mindspring.com.
as brightening, contrast,
gamma correction, color
reduction, and rotation, as
well as special effects filters
(mosiac, page curl, wave, tran-
sitions, and more). It also
includes a built-in video frame
grabber and the ImageLib
WebKit.
Skyline Tools
Price: US$599
Phone: (818) 766-3900
Web Site: http://www.imagelib.com

News Borland Announces Delphi Enterprise
Scotts Valley, CA — Borland
announced Delphi
well as optional enterprise
consulting services.
from Borland and through
select Borland partners. For
L I N E Enterprise, an integrated Delphi Enterprise prices more information, call
development and middle- start at US$45,000, depend- Borland’s direct corporate
ware solution for corpora- ing on developer seats and sales at (408) 431-1064, or
February 1998
tions building secure, fault- server configuration. The visit the Borland Web site at
tolerant, distributed software product is available directly http://www.borland.com.
applications. Based on
Delphi development tools Borland Reports Second Quarter
and Entera middleware tech- Fiscal 1998 Results
nology, Delphi Enterprise Scotts Valley, CA — percent increase over rev-
provides a robust, multi- Borland announced results enues of US$77,452,000
platform, end-to-end solu- for its fiscal year 1998, sec- for the first half of fiscal
tion that can support large ond quarter, which ended year 1997.
volumes of users and data. September 30, 1997. Net income for the second
Delphi Enterprise allows cor- Second quarter revenues quarter of fiscal year 1998
porations to deliver enterprise- for fiscal 1998 were was US$1,518,000, or
class applications that lever- US$42,500,000, compared US$.03 earnings per share,
age their corporate assets, to US$39,306,000 for the as compared to a net loss of
including investments in second quarter of the previ- US$14,310,000 or US$.40
Borland Signs Letter of legacy systems, developer ous fiscal year. (Revenues per share for the second
Intent, Releases C++Builder skill sets, infrastructure, and were up eight percent over quarter of fiscal year 1997.
Client/Server Suite
current business practices. the second quarter of fiscal Revenues from Borland’s
Borland signed a letter of intent
with IBM Corp. to jointly develop Delphi Enterprise year 1997.) client/server, enterprise, and
and deliver Java development includes technical support, Year-to-date fiscal year Internet products continued to
solutions for IBM AS/400e series
business computers.
installation, training, and 1998 revenues were grow, making up 55 percent of
Borland and IBM will work to pro- maintenance contracts, as US$84,470,000, a nine- total revenues in the second
vide AS/400 developers with inte- quarter of fiscal year 1998.
grated solutions for developing Java
applications and applets. The devel-
Arabic Language Support for Delphi 3 Borland attributes its prof-
opment solutions will be based on Scotts Valley, CA and Delphi Arabic Enablement itability to continued
Borland’s new JBuilder family of
pure Java development tools. Frankfurt, Germany — for Delphi 2 and 3 is avail- updates on existing products,
Borland also released Borland announced the able from Borland and select as well as new products, such
C++Builder/400 Client/Server
Suite, a C++-based RAD tool
availability of Arabic lan- distributors for US$99. as JBuilder.
specialized for the IBM AS/400 guage support for Delphi 3
series of business computers. Client/Server Suite and the SAP Announces Open BAPI Network
Borland’s C++Builder/400 com-
bines native connectivity to the Delphi 2 and Delphi 3 line Atlanta, GA — Systems, within SAP itself. The Open
AS/400, a reusable object-oriented of tools. With Delphi Arabic Applications, and Products in BAPI Network ensures that
component library and high
productivity visual design tool. Enablement for Windows Data Processing (SAP) AG developers building applica-
C++Builder/400 Client/Server 95, any existing installation launched the Open BAPI tions complementary to R/3
Suite is available from Borland and of Delphi 2 or 3 running on Network to encourage the free have access to information for
authorized Borland/400 business
partners. Prices start at US$3,995. Arabic Windows 95 can be flow of information among BAPI-based development.
For more information call (800) upgraded to develop full developers using its Business For information or to regis-
233-2444 or visit http://www.bor-
land.com/borland400/. Arabic applications, includ- Application Programming ter for membership visit the
International customers can contact ing Arabic database, report- Interfaces (BAPI) at customer SAP Web site (http://www.-
their local Borland office or visit
http://www.borland.com/-
ing, and display capabilities. sites, partner companies, and sap.com).
borland400/partner.html.

On the Cover
Delphi 3 / ActiveX
By Dan Miser
Delphi 3 ActiveX
A Handy Introduction
M icrosoft has defined a lightweight subset of their OLE technology that is

well suited for the Internet. This technology is called ActiveX. Delphi 3
gives developers the ability to easily use existing ActiveX controls in their appli-
cations, as well as turn their native VCL components into ActiveX controls.
Delphi 3 also provides developers the ability to extend ActiveX controls, and
even create custom ActiveX controls from scratch.
This article demonstrates five aspects of converting a Delphi form into an

ActiveX programming with Delphi 3: ActiveForm
importing existing ActiveX controls
converting VCL controls into ActiveX That’s a lot of ground to cover, so let’s get to
controls it. (Note: You’ll need Microsoft Internet
extending an ActiveX control by adding a Explorer version 3 or higher to access
property page ActiveX controls on the Web. For Netscape
creating custom ActiveX controls users, a plug-in called ScriptActive will allow
ActiveX access. It’s available from NCompass
Labs at http://www.ncompasslabs.com.)
Importing an Existing ActiveX Control

Because they’re components, ActiveX con-
trols fit nicely into Delphi’s component-
based development strategy. In fact, Delphi
3 gives you the ability to integrate these con-
trols right into the Delphi IDE. Select
Component | Import ActiveX Control from the
menu to display the list of ActiveX controls
registered on your system. Any control
found in this list can be imported as a
Delphi component.
The following example will demonstrate

how to install an ActiveX control, and how
to use it in the Delphi 3 IDE. To follow
this example, you must have Progressive
Networks’ RealAudio ActiveX control
installed on your system; you can find it at
http://www.real.com/products/player/-
Figure 1: The Import ActiveX Control dialog box. playerdl.html.
On the Cover
Figure 2: The RealAudio ActiveX control in action. Figure 3: The ActiveX Control Wizard.
Select Component | Import ActiveX Control, and modify the Not all VCL controls can become ActiveX controls; to display
dialog box to look like that shown in Figure 1. If you were a VCL control in the ActiveX Control Wizard, three require-
to click the Create Unit button, Delphi would generate a ments must be met:
VCL wrapper by reading the type information of the The VCL control must descend from TWinControl. This
ActiveX control, and translating it into Object Pascal syn- may force you to alter the parentage of your VCL control,
tax. The source code would then be saved in the directory but there is usually a suitable alternative. For example, if
you specified for Unit dir name. you’re trying to port a non-visual control to an ActiveX
control, you might consider using TCustomControl as the
However, because all Delphi 3 components need to be ancestor, and provide a simple Paint method.
installed to a package before you can use them in the The VCL control must descend from a control capable of
Delphi IDE, you should click the Install button. This will supporting ActiveX conversion. Most Delphi components
create the unit as previously described, then allow you to use the RegisterComponents procedure to install themselves
insert the component into a package by using Delphi’s stan- to the Component palette. However, if you don’t want a
dard component-installation dialog box. Next, you’ll be control to be converted to ActiveX, you can use the
prompted to rebuild the modified package. After recompil- RegisterNonActiveX procedure to install the component. A
ing, you can treat the ActiveX control as you would any common reason to disallow ActiveX conversion is that the
native VCL component. VCL control references other components. Having
ActiveX controls talk to each other in this manner would
You may have noticed the Add and Remove buttons on this be very difficult, so it’s easier to disallow the conversion
dialog box. These give you a quick, easy way to install and altogether. Delphi’s data-aware controls are a prime exam-
remove ActiveX controls without resorting to Regsvr32, or ple of this. Also, registering a control with
some other registration utility. Figure 2 shows a RealAudio RegisterNonActiveX will disqualify that control’s descen-
component on a form; its Source property is set to a dent components.
RealAudio file, and Play is selected from the context menu. The VCL control must be installed in Delphi. If the com-
Notice that the file is being played at design time. ponent isn’t installed in the Component palette, it’s not
registered with Delphi.
Creating ActiveX Controls from VCL Controls
You may be wondering how to create your own ActiveX Once you click OK, Delphi will convert the VCL control
control that others may use. Delphi comes to the rescue to an ActiveX control. Because an ActiveX control is based
again by providing the ability to convert VCL controls to on OLE, the VCL control can only translate properties
ActiveX controls. This capability is not restricted to that have a corresponding native OLE data type. In addi-
Borland’s standard VCL controls; you can even convert tion, you can provide an adapter to convert the nonstan-
your custom VCL controls. dard data type into something that OLE can understand.
For example, Delphi comes bundled with adapters, so
Select File | New | ActiveX | ActiveX Control to run the ActiveX OLE can use properties of types TString, TPicture, and
Control Wizard. This will generate a fully functional imple- TFont. If Delphi can’t map a data type to a type that OLE
mentation of the ActiveX control, which you can use from can understand, Delphi will omit that property from the
within your Delphi applications. For now, let’s build a sample generated ActiveX control. You can add properties and
ActiveX control based on Delphi’s Calendar control (which methods to the ActiveX control manually by selecting Edit
appears on the Samples page of the Component palette). | Add To Interface, or editing the type library itself. Or, you
Modify the ActiveX Control Wizard to look like the dialog can use the Type Library editor (by selecting View | Type
box in Figure 3, and click OK. Library) and have Delphi 3 do most of the work.

On the Cover
library CalendarX;
uses
ComServ,
CalendarX_TLB in 'CalendarX_TLB.pas',
CalImpl in 'CalImpl.pas' { CalendarX: CoClass },
CalPage in 'CalPage.pas' { CalendarPage: TPropertyPage };
exports
DllGetClassObject,
DllCanUnloadNow,
DllRegisterServer,
DllUnregisterServer;
{$R *.TLB}
{$R *.RES}
{$E ocx}
begin
end.
Figure 4: The source file for CalendarX. Figure 5: TCalendarPage at design time.
Once the code is generated for the ActiveX control, we can To continue our example project, we’ll give CalendarX the
manipulate it as we would any other Delphi project. For now, ability to edit the date, in a property page. Create a property
we’ll save the control, then compile it by using the Project | page by selecting File | New | ActiveX | Property Page. Press OK
Build All menu item.
to generate skeleton code for a property page. After the form
has been created, modify it to look like the one in Figure 5.
After you’ve compiled the ActiveX control and registered it
with the system, any application that can use ActiveX con- The OK, Cancel, and Apply buttons are all provided for you.
trols for development can now access this control. Just for In addition, the tabbed notebook reflects the number of
fun, you can import your resulting ActiveX control into property pages you’ve created. The only controls you need to
Delphi using the steps previously covered. This will allow place on a property-page form are those that implement the
you to view this control as other users might. desired behavior of the property page.
Anatomy of an ActiveX Control The following steps are necessary to completely implement a
Every project created in Delphi needs a project source file property page:
(a .DPR file). ActiveX controls are no exception. An 1) Update the visual controls of the property page to match
ActiveX Library is the project source file for all ActiveX the state of the ActiveX control.
projects. This file exports the four signature methods of an 2) Modify the visual controls.
ActiveX control, provides an extension compiler directive, 3) If necessary, update the ActiveX control’s properties to
and includes the appropriate type library. reflect the changes made in the property page. This is
done only if the OK or Apply button is pressed.
The source file for an example calendar project, CalendarX, is
shown in Figure 4. The compiler directive: Delphi supplies all the pieces to easily implement this logic.
The UpdatePropertyPage method will be called whenever the
{$E ocx}
property page is about to be displayed. This is where you set
the visual controls to show the ActiveX control’s properties.
tells Delphi what extension to give to the compiled version of
For example, the following method will set the edit controls
the project. To create a new ActiveX Library project from
to the values of the ActiveX control:
scratch, you would select File | New | ActiveX | ActiveX Library.
procedure TCalendarPage.UpdatePropertyPage;
The CalendarX control is good, but it would be nice to offer begin
an easier way to edit the properties. This is precisely what edMonth.Text := OleObject.Month;
edDay.Text := OleObject.Day;
property pages were made for. edYear.Text := OleObject.Year;
end;
Property Pages
Property pages give users a friendly way to alter the prop- The TPropertyPage object contains a reference to the ActiveX
erties of an ActiveX control. A property page has a visual control, and places it in a variable called OleObject. Access
control that represents a corresponding ActiveX property. this variable whenever you need to access properties or meth-
These controls are displayed in a tabbed notebook. ods of the ActiveX control.
On the Cover
The ActiveX control must be informed when its properties
change. Whenever a user changes a property via a property
page, you need to call the Modified method of the property
page. This tells the ActiveX control that it needs to update
itself. For example, the following method is assigned to each
Edit component’s OnChange event:
procedure TCalendarPage.EditChange(Sender: TObject);

begin
Modified;
end;
The UpdateObject method is called when the ActiveX control

is about to set its contents from the property page. Basically,
you assign the values you set in UpdatePropertyPage back to
the OleObject of the ActiveX control.
Register the Page Figure 6: A standard ActiveX property page at run time.
The last step is to bind the property page to the ActiveX con-
trol by registering it. This is accomplished by calling the control from scratch. Here’s where studying Delphi’s gener-
DefinePropertyPages procedure inside the ActiveX control’s ated code really pays off.
DefinePropertyPage method. This method was created in the
skeleton code when you created the ActiveX control. Simply pass TreeView components are not listed in the ActiveX
the CLSID of the page that you want to register. You can find Control Wizard mainly because the Items property is of
this value in the interface portion of the property-page unit: type TTreeNodes. This is not an OLE-compatible type, so
procedure TCalendarX.DefinePropertyPages(
there is no automatic way for Delphi to make this struc-
DefinePropertyPage: TDefinePropertyPage); ture ActiveX-compliant. However, with a little reengineer-
begin ing, we can expose some of the functionality of the Items
DefinePropertyPage(Class_CalendarXPage);
DefinePropertyPage(Class_DFontPropPage);
property, thus allowing the control to be manipulated as an
end; ActiveX control.
Note also that you’ll need to add the name of the property- To create this ActiveX control, first make sure all the files are
page unit to the Calendar ActiveX unit (that’s where you closed inside Delphi. Then:
defined Class_CalendarXPage). 1) Select File | New | ActiveX Library to get the project file
used by ActiveX controls. This creates the project frame-
Every property page you define creates another tab on the work for an ActiveX control.
property-page editor. This lets the user concentrate on one 2) Select File | New | Automation Object, and give the object
logically related group of data at a time. For example, you a class name of TTreeViewX. This will create a COM-
could create one property page for modifying the fonts object declaration, as well as a type library. Both these
used in a control, and another for modifying graphic ele- files will be modified throughout the rest of this process.
ments. This would require calling the DefinePropertyPage 3) Make the following changes to the source-code statements
method for each PropertyPage you want to register for this in the Automation Object unit: The TTreeViewX class
ActiveX control. must descend from TActiveXControl instead of TAutoObj.
The factory-creation class in the initialization section
You can also easily give your control the ability to modify must read:
properties of type TFont, TColor, TPicture, and TStrings.
TActiveXControlFactory.Create(ComServer, TTreeViewX,
These property pages will scan through your ActiveX control’s TTreeView,
properties at run time, and let the user modify individual Class_TreeView, 1, '', 0)
attributes of these properties. These property pages are imple-
mented in Stdvcl32.dll; therefore, if your control accesses one 4) Add the extension directive to the project source file. This
of the standard property pages (see Figure 6), you’ll need to step ensures that when you compile the project, the
deploy this file as well. resulting binary file will have the standard ActiveX exten-
sion — namely, OCX:
ActiveX from Scratch
We’ve seen the powerful ability of Delphi to generate {$E ocx}
ActiveX controls by using the ActiveX Control Wizard, but

what do you do if your control isn’t listed there? Aside 5) Borrowing heavily from a Delphi-generated ActiveX
from the simple case where you have full control of the control, make the following modifications to the
component’s parentage, you’ll need to create the ActiveX TTreeViewX class:
On the Cover
procedure TTreeViewX.AddChild(const RootIndex,
Index: Integer; const S: WideString);
var
ARoot, AChild : TTreeNode;
i : Integer;
begin
// Find the right root position.
ARoot := FDelphiControl.Items.GetFirstNode;
for i := 0 to RootIndex-1 do
if ARoot <> nil then
ARoot := ARoot.GetNextSibling;
// Now find the right child position.

if (ARoot <> nil) and
(ARoot.HasChildren) then
begin
AChild := ARoot.GetFirstChild;
for i := 0 to Index-1 do
Figure 7: The Type Library editor.
if (AChild <> nil) and
(AChild.GetNextChild(ARoot) <> nil) then
TTreeViewX = class(TActiveXControl, ITreeViewX) AChild := AChild.GetNextChild(ARoot);
private FDelphiControl.Items.Add(AChild, S);
FDelphiControl: TTreeView; end
FEvents: ITreeViewXEvents; else
protected // If sorted, inserted in sort order; else, inserted
procedure InitializeControl; override; // as last child node.
procedure EventSinkChanged (const EventSink: FDelphiControl.Items.AddChild(ARoot,S);
IUnknown); override; end;
procedure DefinePropertyPages (DefinePropertyPage:
TDefinePropertyPage);
procedure TTreeViewX.AddRoot(const Index: Integer;
override;
const S: WideString);
begin
These methods will provide the link between the VCL if FDelphiControl.Items.Count = 0 then
FDelphiControl.Items.Add(nil, S)
control and the ActiveX control. Whenever you make a else if (Index>=0) and
change to the ActiveX control, you’ll actually pass that (Index<FDelphiControl.Items.Count) then
change on to the VCL control that it represents. See the FDelphiControl.Items.Add(FDelphiControl.Items[Index],S);
end;
source code for this month’s article for the complete
implementation of this control (see end of article for Figure 8: The AddRoot and AddChild methods.
download details).
methods to the type library will give TTreeViewX users a way
The skeleton for TTreeViewX is now complete. To allow to add items programmatically. The implementation of these
access to the properties, methods, and events of the TreeView methods is shown in Figure 8.
control, we need to add these elements to the ActiveX wrap-
per through the type library. Registering the ActiveX Control
After building an ActiveX control, you can take advantage
For example, to add the Indent property to the control, select of Delphi’s ability to register the control for you. Select
View | Type Library to invoke Delphi’s visual Type Library edi- Run | Register ActiveX Server to create the required registry
tor (see Figure 7). Select the ITreeViewX interface, and press settings for the ActiveX control. Once registered with your
the Property button. Name this property Indent. Next, press system, you can use the ActiveX control in any capable
the Refresh button. This will add two methods to the environment — including Visual Basic and ActiveX
TTreeViewX class: Get_Indent and Set_Indent. This is where Control Pad.
the communication between the VCL control and the
ActiveX wrapper occurs. Of course, selecting Run | Unregister ActiveX Server will
remove the ActiveX control from the registry. We’ll cover this
For the Indent property, it’s a simple matter of reading and topic in more depth next month, when we explore the issues
writing the value of FDelphiControl.Indent. Enumerated types concerned with deploying ActiveX controls.
are only slightly more complex to deal with, because you
need to typecast the result to the appropriate type. You can ActiveForms
learn a lot by looking at one or two Delphi-generated Delphi 3 has supplied you with the ability to easily turn an
ActiveX control wrappers. existing form into an ActiveX control known as an
ActiveForm. The only real difference between an ActiveForm
A TreeView control without items is like a vintage car with- and an ActiveX control is that the ActiveForm will likely
out a steering wheel: It might be interesting to look at, but contain several visual controls. You can think of it as a
you’ll never use it. We need to provide a way to add items to super-component if you want. ActiveForms give you the
this control without exposing the TTreeNodes structure to ability to deploy almost any Delphi form via the Web.
the outside world. Creating the AddChild and AddRoot However, there are some limitations to what an ActiveForm
On the Cover
Figure 10: The Add To Interface dialog box.
opment environment by assigning a value to the Search

property of the ActiveForm:
Figure 9: The ActiveForm at design time.
function TAFEmployee.Get_Search: WideString;
begin
can do. For example, an ActiveForm cannot be a robust,
Result := edSearch.Text;
multi-form application. If you need to access multiple end;
screens in your ActiveForm, consider using a Tabbed
procedure TAFEmployee.Set_Search(const Value: WideString);
Notebook interface instead.
begin
edSearch.Text := Value;
Creating an ActiveForm end;
Let’s create a simple ActiveForm to view and edit information
from the Employee table found in \Dbdemos. To create an We can further extend this control by adding functionality to
ActiveForm, select File | New | ActiveX | ActiveForm. An programmatically search a database, and even control the visi-
ActiveX Library will be built for you, if necessary. bility of all the search-related controls. In addition, because
this really is an ActiveX control, we could even add property
(Note: This demonstration requires BDE 4.0 to be installed pages to this ActiveForm, and import the control for use
on every client machine that will access this ActiveForm. You within Delphi.
can also deploy a thin-client solution by using MIDAS. For
more information on how to use MIDAS in a Delphi appli- Conclusion
cation, see http://www.borland.com/midas.) So there you have it — a whirlwind tour. From simply
importing them, to creating your own, in this article we’ve
An ActiveForm is really not much different than a standard quickly covered many aspects of Delphi 3 ActiveX program-
Delphi form. For this example, we’ll place some standard ming. In my next article, we’ll discuss techniques for deploy-
data-aware controls on the ActiveForm, as shown in Figure 9. ing ActiveX controls and ActiveForms, including how, when,
Notice that we can still use the standard Table and and why to use run-time packages with your ActiveX con-
DataSource components to drive our data-aware controls. trols, and how to deploy them to the Web with INF and
CAB files. ∆
Once all the controls are configured, we can save, compile,
and register the ActiveForm as we would any other ActiveX The projects referenced in this article are available on the Delphi
control. At this point, you could use the ActiveX control in Informant Works CD located in INFORM\98\FEB\DI9802DM.
Visual Basic, with all its functionality intact. However, it
would be nice to give the ActiveX user an interface to control
some individual elements of this super-control.
Because an ActiveX control is a DLL, you can’t directly

access public variables inside the control. Instead, access to
the underlying variables of a form must occur through a pro-
cedural interface. Use Edit | Add To Interface to make a prop- Dan Miser is a software developer residing in Southern California with his wife
erty accessible to the outside world. For even more control and daughter. He has been a Borland Certified Client/Server Developer since
over this interface, use the Type Library editor to manipulate 1996, and is a frequent contributor to Delphi Informant. You can contact him
all the attributes of the associated type library. at http://www.iinet.com/users/dmiser.
In our example, we would like to give the user a program-

matic way to control the contents of the Search edit con-
trol’s text property. Select Edit | Add To Interface to display
the dialog box shown in Figure 10. This will create two
stub methods to your ActiveForm: Get_Search and
Set_Search. Fill in the two methods to get and set the
edSearch.Text property of the ActiveForm, respectively.
Now you can access edSearch.Text from any ActiveX devel-
Informant Spotlight
Delphi 3 / ActiveX Scripting
By Tom Stickle
ActiveX Scripting
Adding Scripting to Your Delphi 3 Applications
F or advanced applications that require customization, a scripting language

can be a useful feature. Unfortunately, numerous factors have deterred
developers from providing scripting support in their applications: Creating a
new scripting language from scratch absorbs a great deal of development time
while increasing long-term training and support costs, and licensing a scripting
engine from a third-party company is a potentially expensive undertaking that
creates a dependency on the vendor.
With the arrival of ActiveX scripting, devel- (currently available free of royalties), VBA,
opers finally have a vendor-independent plat- JavaScript, or Perl — without changing a
form that enables them to add standard single line of code.
scripting support to their applications. By
using the Component Object Model (COM), The ActiveX scripting implementation con-
ActiveX scripting provides a common set of sists of two inter-related COM objects: the
interfaces that allow developers to access vari- scripting engine and the scripting host. The
ous scripting languages in the same manner. scripting engine is the COM object that
Your application need not care what language processes scripts, i.e. VBScript or JScript.
the script is written in, because the script exe- The scripting host is a COM object that is
cutes in a separate object known as a scripting tied to our application. Figure 1 shows the
engine. For example, if your application sup- basic architecture of ActiveX scripting. The
ports ActiveX scripting, you can use idea is that the scripting host object is
Microsoft’s Visual Basic Scripting Edition responsible for creating our application’s cus-
tom COM objects, as well as han-
dling communication from the
scripting engine to the applica-
tion. This is accomplished by “fas-
tening” the scripting host to the
scripting engine at the time the
engine is initialized.
The Scripting Engine

To successfully implement ActiveX
scripting in an application, you
first need a basic knowledge of the
interfaces and methods available.
In this article, we’ll tackle the com-
Figure 1: The basic architecture of ActiveX scripting. monly used interfaces and methods
Informant Spotlight
function TScriptingDemo.InitEngine : Boolean;
Getting Started
var To link our application to the scripting engine, we create a
CatID: TGuid; COM object of our own, known as the Script Site Object.
begin
Result := False;
You’ll notice the interface declarations for this object in the
Activescp.pas file as well, but unlike the scripting engine, we
{ Choose CatID based on the menu selection. } are responsible for implementing this object. The Script Site
if tmVBScript.Checked then
CatID := CatID_VBScript
Object is responsible for providing the scripting engine with
else any available application objects and an interface for retrieving
CatID := CatID_JScript; error information such as syntax and run-time script errors.
ActiveScript := IActiveScript(CreateComObject(CatID));
For our demonstration, we’ll be implementing two interfaces:
IActiveScriptSite. This interface provides the primary
{ Get Interface pointer for method of communicating from the scripting engine to
IActiveScriptParse Interface. }
if (ActiveScript.QueryInterface(IID_IActiveScriptParse,
our application.
ActiveScriptParse) <> S_OK) then IActiveScriptSiteWindow. This is a simple interface that
Exit; passes the scripting engine a window handle from our
{ Instantiate Site Object. }
application. By implementing this interface, any windows
ActiveScriptSite := that are created by our script will appear to be a seamless
IActiveScriptSite(TActiveScriptSite.Create); part of our application.
{ Register Site Object with the ActiveScript Engine. }
if ActiveScript.SetScriptSite( As seen in Listing Two (beginning on page 16), the
ActiveScriptSite) <> S_OK then Scriptsite.pas file contains the implementation for this
Exit;
object. Although we are implementing all methods, we are
{ Initialize the engine. } really only adding processing for two methods:
if (ActiveScriptParse.InitNew <> S_OK) then OnScriptError. This is triggered whenever a design- or
Exit;
run-time error occurs when processing a script. By imple-
{ Now fire up the scripting engine. } menting this method, we’re able to provide users with
if ActiveScript.SetScriptState( meaningful information about an error, such as the line
SCRIPTSTATE_CONNECTED) <> S_OK then
Exit;
and column of a syntax error.
GetWindow. This is triggered whenever the scripting
{ If we made it this far then we have succesfully engine needs to obtain a window handle.
initialized the engine! }
Result := True;
end; Starting the Engine
As mentioned earlier, one of the great benefits of the
Figure 2: Starting a scripting session. ActiveX Scripting architecture is the ability to switch
scripting engines without modifying your application
with enough detail to get you started. For more information, code. You may be wondering how our application can tell
consult Microsoft’s Web site at http://www.microsoft.com. the difference between the VBScript Engine interfaces and
the JScript interfaces. After all, each interface has the same
The scripting engine is made available through a series of name and is defined by the same globally unique identifier
COM interfaces. Although there are several optional inter- (GUID). We are able to differentiate the various engines
faces that can be used in different scenarios, our application because the engine provider is required to group the inter-
will interact with the following three: faces together with a special type of GUID known as a
IActiveScript. This interface is the primary means of com- category identifier (CatID). The scripting engine we inte-
municating from our application to the scripting engine. grate with is determined by which CatID we submit when
It provides a mechanism for starting and stopping the instantiating the COM interfaces. This means we can easi-
scripting engine. ly swap scripting engines without changing a single line of
IActiveScriptParse. This is an interface to the parser that code, even at run time.
allows us to submit a script at run time.
IActiveScriptError. An instance of this interface is returned You can now create a Delphi method to handle the steps
to us by the scripting engine when an error occurs. We required to start our scripting session (see Figure 2). We first
can use it to request more detailed error information. create an instance of the scripting engine by calling
CreateComObject and pass in the category identifier of the
For our demonstration application, the Activescp.pas file scripting engine we want to instantiate. When doing this,
(see Listing One beginning on page 15) contains the be sure the variables storing those interface pointers are
Delphi wrapper for accessing the scripting engine’s global, since Delphi 3 will release them as they go out of
automation interfaces (see end of article for download scope. Once we have a handle to IActiveScript, we can easily
details). With the drudgery of creating the wrapper out of query out the IActiveScriptParse interface. At this point, we
the way, we can now focus on the details of those inter- instantiate our IActiveScriptSite object and pass it into the
faces and methods. engine. This step bridges the two objects together for the
Informant Spotlight
function TScriptingDemo.ParseScript( procedure TScriptingDemo.FireMethod(
const ScriptText: WideString): Boolean; const EventName: WideString);
var var
Ei: TExcepInfo; Disp: Integer;
Flags: DWord; DispParams: TDispParams;
VarOut: OleVariant; Ei: TExcepInfo;
begin InvKind: Integer;
Flags := SCRIPTTEXT_NULL; ReturnVal: POleVariant;
Result := (activeScriptParse.ParseScriptText( ScriptDispatch: IDispatch;
ScriptText, nil, nil, nil, begin
0, 0, Flags, VarOut, Ei) = S_OK);
end; if ActiveScript.GetScriptDispatch(
nil, ScriptDispatch) <> S_OK then
Figure 3: Submitting a script for parsing and execution. Exit;
{ Initialize dispatch id. }

procedure TScriptingDemo.StopEngine; Disp := -1;
begin
ActiveScript.SetScriptState(SCRIPTSTATE_UNINITIALIZED); { Get a dispatch id number that corresponds to
end the EventName name. }
ScriptDispatch.getIDsOfNames(GUID_NULL, @eventName, 1,
Figure 4: Reinitializing the scripting engine.
LOCALE_USER_DEFAULT, @disp);
session. The last step is to call InitNew, then change the { See if anything was found for the EventName --
Spelling Error will fail! }
engine state to connected. We have now successfully fired if disp = -1 then
up the scripting engine. begin
ShowMessage(Format(
'The method %s was not found in the script...',
Parsing the Script [EventName]));
Now that we have a mechanism for starting the engine, we Exit;
must have a way to submit our script for parsing and exe- end;
cution. This is accomplished through the use of the { Set the type of invocation to method. }
IActiveScriptParse interface and its ParseScriptText method. InvKind := DISPATCH_METHOD;
We can conveniently bundle this call into a Delphi
{ This structure can contain up to 32 arguments to pass
method (see Figure 3). in, but we will not pass any in the demo. }
ReturnVal := nil;
Resetting the Engine DispParams.rgvarg := nil;
DispParams.rgdispidNamedArgs := nil;
In many cases, you’ll probably want the ability to submit a DispParams.cArgs := 0;
script, execute it, but then reset the engine so you can repeat DispParams.cNamedArgs := 0;
the process with another script. This can be done by chang-
{ Fire the Event via ID Binding. }
ing the script state from connected to uninitialized. The ScriptDispatch.Invoke(Disp, GUID_NULL, 0, InvKind,
Delphi method shown in Figure 4 accomplishes this. DispParams, ReturnVal, @ei, nil);
end;
Firing a Script Subroutine Figure 5: ID binding allows for generic code to call a routine
Fortunately, the scripting engine gives us the ability to selec- in script.
tively fire individual subroutines or functions in the script
from our Delphi application. This is possible because the
scripting engine exposes all subroutines through an automa- We simply query the IDispatch interface for the DispID that
tion interface at the time the script is parsed. We can now corresponds to the name of a script routine, and then invoke
treat the methods in the script as if they were methods in any that method based on the DispID. This technique is known
standard dual automation object. as ID binding, and enables us to create generic code for call-
ing a routine in the script (see Figure 5).
A dual automation object is essentially an ordinary COM
object. As with any COM object, it has a vtable that con- Exposing Application Objects to the Script
tains pointers to its methods and properties. The big dif- For the scripting engine to have true significance to an
ference is that it also contains a dispatch interface — or application, we must be able to expose an application’s
dispinterface — that assigns a unique integer identifier, Automation objects to the script, so that users can easily
referred to as a dispatch identifier (DispID), to each access them without knowledge of COM. After all, one of
method and property. The second major difference is that the major advantages a scripting language provides is that
a dual automation object inherits from an interface, called users can control the logic of complex tasks without having
IDispatch, which provides a method for calling any other to know all the details. For example, a script writer may add
methods in the vtable based on its DispID. the following code to a script:
if CountDown = 0 then
The clear advantage of this mechanism is that we now have Rocket.Launch
the ability to execute any routine in the script at run time. end if

Informant Spotlight
engine’s namespace by adding the following to your
procedure TMyObj.ShowCelcius(DegreesF: Integer);
var InitEngine method before the connection is made:
DegreesC : Integer;
begin Flags := SCRIPTITEM_ISVISIBLE;
DegreesC := (DegreesF - 32) * 5 div 9; ActiveScript.AddNamedItem('MyObj', Flags);
MessageDLG(Format(
'%d degrees Fahrenheit is equal to %d degrees Celcius.',
[DegreesF, DegreesC]) , mtInformation, [mbOK], 0 ); When a script is parsed, the engine will now be aware of an
end; object called MyObj. If the script contains a reference to
MyObj, the scripting engine will call the GetItemInfo method
Figure 6: The ShowCelcius method.
of our Script Site Object to obtain an instance of the actual
object; add the code shown in Figure 7 to accomplish this.
function TActiveScriptSite.GetItemInfo(
ItemName: WideString; dwReturnMask: DWord;
out UnkItem: IUnknown; out TypeInfo: ITypeInfo): HResult;
Testing
var Now lets look at ActiveX scripting in action. In our sample
ObjDispatch: IDispatch; code editor, create a simple routine that references our COM
begin
{ This method is called when the engine wants information
object and calls a method in it:
about an object that we submitted by calling
Sub Main
AddNamedItem. Using Delphi 3, the instances created
Dim ANumber
here will be freed when they go out of scope. }
ANumber = InputBox( _
"Please enter a temperature (F) to convert")
{ Does the engine want the Automation object's IUnknown
MyObj.ShowCelcius ANumber
pointer? }
End Sub
if (dwReturnMask = SCRIPTINFO_IUNKNOWN) and
(ItemName = 'MyObj') then
UnkItem := CoMyObj.Create; When you fire off this code in the editor, you’ll be prompted
{ Does the engine want the Automation object's
for a Fahrenheit temperature; a message box will then appear
type information? } with the appropriate conversion. Of course, you should try
if (dwReturnMask = SCRIPTINFO_ITYPEINFO) and running the code with a syntax error to see how the engine
(ItemName = 'MyObj') then
begin
reports it through the Script Site Object.
ObjDispatch := CoMyObj.Create;
{ Get a handle to our Automation object's The last thing to try is to switch the sample application’s script-
type library. }
ObjDispatch.GetTypeInfo(0,0,TypeInfo);
ing engine from VBScript to JScript. Because JScript has no
end; built-in support for simple input and output statements such as
the Visual Basic MsgBox and InputBox, we would have to use
Result := S_OK;
end;
our custom Automation objects to collect input and display out-
put to the user. For simplicity, we can type in the following code:
Figure 7: The GetItemInfo method.
function Main() {
MyObj.ShowCelcius(98);
In this scenario, the three lines of VBScript handle the flow }
of control, but the Delphi Rocket object provides the intelli-
gence and power to handle the details. Installing the sample. For the sample application to work on
your machine, you must install the Visual Basic Scripting edi-
To demonstrate how you can expose the complex logic of an tion. The latest version of VB Scripting edition is available at
application to the scripting language, you can create a simple http://www.microsoft.com/vbscript.
COM Automation object using Delphi 3. Although you
might normally store your application objects in an ActiveX Conclusion
Library (.DLL), for simplicity, you can add it to the current The addition of ActiveX scripting to your Delphi applications
project. The first step is to request a new ActiveX object by provides the ability to include powerful application objects in
selecting File | New | ActiveX | Automation Object to invoke a familiar, easy-to-use, scripting language. Your users can then
the Type Library editor. Add a new interface named IMyObj, manipulate the flow of an application while leaving the com-
with a method called ShowCelcius. plex details to you. ∆
You can implement ShowCelcius as shown in Figure 6. This is The files referenced in this article are available on the Delphi
a simple routine that converts Fahrenheit temperatures to Informant Works CD located in INFORM\98\FEB\DI9802TS.
Celcius. Be sure to add Dialogs and Demo_TLB to the uses
statement, register the type library using the Type Library edi-
tor, and then register the new object with the OS.
We need to make two modifications to make our new object Tom Stickle lives in Phoenix, AZ. He can be reached at (602) 598-1890, or via
available to scripting applications. When you initialize the e-mail at [email protected].
scripting engine, you can add the name of your object to the
Informant Spotlight
Begin Listing One — ACTIVESCP.PAS SCRIPTTHREADSTATE_RUNNING = 1;
unit Activscp; { Thread IDs }

type
interface SCRIPTTHREADID = DWORD;
{ Interface specification for ActiveX Scripting. } const

uses SCRIPTTHREADID_CURRENT = SCRIPTTHREADID(-1);
Windows, comobj, activeX; SCRIPTTHREADID_BASE = SCRIPTTHREADID(-2);
SCRIPTTHREADID_ALL = SCRIPTTHREADID(-3);
{ IActiveScript.AddNamedItem input flags. }
const { GUIDs }
SCRIPTITEM_ISVISIBLE = $00000002; const
SCRIPTITEM_ISSOURCE = $00000004; { Category IDs }
SCRIPTITEM_GLOBALMEMBERS = $00000008; CATID_VBScript: TGUID =
SCRIPTITEM_ISPERSISTENT = $00000040; '{ B54F3741-5B07-11CF-A4B0-00AA004A55E8 }';
SCRIPTITEM_CODEONLY = $00000200; CATID_JScript: TGUID =
SCRIPTITEM_NOCODE = $00000400; '{ F414C260-6AC0-11CF-B6D1-00AA00BBBB58 }';
SCRIPTITEM_ALL_FLAGS = (SCRIPTITEM_ISSOURCE + { Class IDs }

SCRIPTITEM_ISVISIBLE + IID_IActiveScriptParse: TGUID =
SCRIPTITEM_ISPERSISTENT + '{ BB1A2AE2-A4F9-11CF-8F20-00805F2CD064 }';
SCRIPTITEM_GLOBALMEMBERS + IID_IActiveScriptSite: TGUID =
SCRIPTITEM_NOCODE + '{ DB01A1E3-A42B-11cf-8F20-00805F2CD064 }';
SCRIPTITEM_CODEONLY ); IID_IActiveScriptSiteWindow: TGUID =
'{ D10F6761-83E9-11cF-8F20-00805F2CD064 }';
{ IActiveScript.AddTypeLib() input flags. }
const { String version of GUIDs }
SCRIPTTYPELIB_ISCONTROL = $00000010; Class_IActiveScriptSite =
SCRIPTTYPELIB_ISPERSISTENT = $00000040; '{ DB01A1E3-A42B-11cf-8F20-00805F2CD064 }';
SCRIPTTYPELIB_ALL_FLAGS = Class_IActiveScriptSiteWindow =
(SCRIPTTYPELIB_ISCONTROL + SCRIPTTYPELIB_ISPERSISTENT); '{ D10F6761-83E9-11cF-8F20-00805F2CD064 }';
{ IActiveScriptParse.AddScriptlet() and type

IActiveScriptParse.ParseScriptText() input flags. } POleVariant = ^OleVariant;
const IActiveScript = interface; { Forward declarations. }
SCRIPTTEXT_NULL = $00000000; { Added for demo. } IActiveScriptParse = interface;
IActiveScriptSite = interface;
SCRIPTTEXT_ISVISIBLE = $00000002;
IActiveScriptSiteWindow = interface;
SCRIPTTEXT_ISEXPRESSION = $00000020;
SCRIPTTEXT_ISPERSISTENT = $00000040;
{ IActiveScript Interface - Methods in VTable order. }
SCRIPTTEXT_ALL_FLAGS = (SCRIPTTEXT_ISVISIBLE
IActiveScript = Interface(IUnknown)
+ SCRIPTTEXT_ISEXPRESSION
function SetScriptSite(ScriptSite: IActiveScriptSite):
+ SCRIPTTEXT_ISPERSISTENT);
HResult; stdcall;
function GetScriptSite(const iid: TIID; out vObj):
{ IActiveScriptSite.GetItemInfo() input flags. } HResult; stdcall;
const function SetScriptState(ScriptState: LongInt):
SCRIPTINFO_IUNKNOWN = $00000001; HResult; stdcall;
SCRIPTINFO_ITYPEINFO = $00000002; function GetScriptState(out ScriptState: LongInt):
SCRIPTINFO_ALL_FLAGS = HResult; stdcall;
(SCRIPTINFO_IUNKNOWN + SCRIPTINFO_ITYPEINFO); function Close:HResult; stdcall;
function AddNamedItem(ItemName: WideString;
{ IActiveScript.Interrupt() Flags. } dwFlags: DWord): HResult; stdcall;
const function AddTypeLib(const GuidTypeLib: TGUID;
SCRIPTINTERRUPT_DEBUG = $00000001; wVerMajor, wVerMinor, wFlags: Word):
SCRIPTINTERRUPT_RAISEEXCEPTION = $00000002; HResult; stdcall;
SCRIPTINTERRUPT_ALL_FLAGS = function GetScriptDispatch(StrItemName: Pointer;
(SCRIPTINTERRUPT_DEBUG + out ScriptDispatch: IDispatch): HResult; stdcall;
SCRIPTINTERRUPT_RAISEEXCEPTION); function GetCurrentScriptThreadID(
wScriptThreadID: Word): HResult; stdcall;
{ Script state enumerations. } function GetScriptThreadState(wScriptThreadID,
type wScriptState: Word): HResult; stdcall;
SCRIPTSTATE = LongInt; { (0..5); } function InterruptScriptThread(wScriptThreadID: Word;
ExcepInfo: PExcepInfo; wFlags: Word):
const HResult; stdcall;
SCRIPTSTATE_UNINITIALIZED = SCRIPTSTATE(0); function Clone(Script: iActiveScript): HResult;
SCRIPTSTATE_INITIALIZED = SCRIPTSTATE(5); stdcall;
function GetScriptThreadID(wWin32Thread,
SCRIPTSTATE_STARTED = SCRIPTSTATE(1);
wScriptThreadID: Word): HResult; stdcall;
SCRIPTSTATE_CONNECTED = SCRIPTSTATE(2);
end;
SCRIPTSTATE_DISCONNECTED = SCRIPTSTATE(3);
SCRIPTSTATE_CLOSED = SCRIPTSTATE(4);
{ IActiveScriptParse Interface - Methods in VTable order. }
IActiveScriptParse = interface(IUnknown)
{ Script thread state values. }
function InitNew: HResult; stdcall;
type
function AddScriptlet(DefaultName, ScriptCode,
SCRIPTTHREADSTATE = LongInt; { 0..1 } ItemName, SubItemName, EventName, Delimiter:
const WideString; wSrcContextCookie: Word; StartLine:
SCRIPTTHREADSTATE_NOTINSCRIPT = 0; Integer; wFlags: Word; StrName: WideString;

Informant Spotlight
var ExcepInfo: TExcepInfo): Integer; stdcall; function GetItemInfo(ItemName: WideString;
function ParseScriptText(MainScript: WideString; dwReturnMask: DWord; out UnkItem: IUnknown;
ItemName: Pointer; UnkContext: IUnknown; out TypeInfo: ITypeInfo): HResult; virtual; stdcall;
EndDelimiter: Pointer; dwSourceCookie: DWORD; function OnScriptTerminate(var VarResult: OleVariant;
StartLineNo: Integer; dwFlags: DWord; var ExcepInfo: TExcepInfo): HResult; virtual; stdcall;
var VarOut: OleVariant; var ExcepInfo: TExcepInfo): function OnStateChange(ScriptState: LongInt): HResult;
HResult; stdcall; virtual; stdcall;
end; function OnScriptError(pAse: IActiveScriptError):
HResult; virtual; stdcall;
{ IActiveScriptError Interface -- function OnEnterScript: HResult; virtual; stdcall;
Methods in VTable order. } function OnLeaveScript: HResult; virtual; stdcall;
IActiveScriptError = interface(IUnknown) { IActiveScriptSiteWindow }
function GetExceptionInfo(var excepInfo: TExcepInfo): function GetWindow(var Hwnd: THandle): HResult; stdcall;
HResult; stdcall; function EnableModeless(FEnable: WordBool):
function GetSourcePosition(out wContextCookie: Word; HResult; stdcall;
out lineNo: UINT; out charPos: Integer): end;
HResult; stdcall;
function GetSourceLineText(wsSourceLine: WideString): implementation
HResult; stdcall;
end; { TActiveScriptSite - Protected Implementation. }
function TActiveScriptSite.GetLCID(var wLCID: TLCID):
{ IActiveScriptSite Interface -- HResult;
We are responsible for implementing this. } begin
IActiveScriptSite = interface(IUnknown) { No need for us to do anything here. }
[Class_IActiveScriptSite] Result := S_OK;
function GetLCID(var wLCID: TLCID): HResult; stdcall; end;
function GetItemInfo(StrName: WideString;
dwReturnMask: DWord; out UnkItem: IUnknown; function TActiveScriptSite.GetItemInfo(
out TypeInfo: ITypeInfo): HResult; stdcall; ItemName: WideString; dwReturnMask: DWord;
function GetDocVersionString(var VersionString: TBSTR): out UnkItem: IUnknown; out TypeInfo: ITypeInfo): HResult;
HResult; stdcall; var
function OnScriptTerminate(var VarResult: OleVariant; ObjDispatch : IDispatch;
var ExcepInfo: TExcepInfo): HResult; stdcall; begin
function OnStateChange(ScriptState: LongInt): { This method is called when the engine wants information
HResult; stdcall; about an object that we submitted by calling
function OnScriptError(pAse: IActiveScriptError): AddNamedItem. Using Delphi 3, the instances created
HResult; stdcall; here will free when they go out of context. }
function OnEnterScript: HResult; stdcall;
function OnLeaveScript: HResult; stdcall; { Does the engine want the Automation object's
end; IUnknown Pointer? }
if (dwReturnMask = SCRIPTINFO_IUNKNOWN) and
{ IActiveScriptSiteWindow is aggregated (ItemName = 'MyObj') then
into IActiveScriptSite. } UnkItem := CoMyObj.Create;
IActiveScriptSiteWindow = interface(IUnknown)
[Class_IActiveScriptSiteWindow] { Does the engine want the Automation object's type
function GetWindow(var Hwnd: THandle): information? }
HResult; stdcall; if (dwReturnMask = SCRIPTINFO_ITYPEINFO) and
function EnableModeless(FEnable: WordBool): (ItemName = 'MyObj') then
HResult; stdcall; begin
end; ObjDispatch := CoMyObj.Create;
{ Get a handle to our Automation object's
implementation Type Library. }
ObjDispatch.GetTypeInfo(0,0,TypeInfo);
end. end;
Result := S_OK;
End Listing One end;
function TActiveScriptSite.GetDocVersionString(
Begin Listing Two — SCRIPTSITE.PAS var VersionString: TBSTR): HResult;
{ This implements the required begin
IActiveScriptSite Interface. } { Tell engine that we will accept its default,
unit ScriptSite; i.e. not implemented. }
Result := E_NOTIMPL;
interface end;
uses
Windows, SysUtils, comobj, activeX, Activscp, Dialogs, function TActiveScriptSite.OnScriptTerminate(
Forms, ComServ, Demo_TLB; var VarResult: OleVariant;
var ExcepInfo: TExcepInfo): HResult;
type begin
{ TActiveScriptSite Declaration. } { This tells us that the script is completed. }
TActiveScriptSite = class(TComObject, IActiveScriptSite, Result := S_OK;
IActiveScriptSiteWindow) end;
protected
{ IActiveScriptSite } function TActiveScriptSite.OnStateChange(
function GetLCID(var wLCID: TLCID): HResult; ScriptState: LongInt): HResult;
virtual; stdcall; begin
function GetDocVersionString(var VersionString: TBSTR): { Alerts us when engine states are changing. }
HResult; virtual; stdcall; Result := S_OK;

Informant Spotlight
end;
function TActiveScriptSite.OnScriptError(
pAse: IActiveScriptError): HResult;
var
wCookie: Word;
ErrString: string;
ExcepInfo: TExcepInfo;
CharNo: LongInt;
LineNo: LongInt;
begin
wCookie := 0;
LineNo := 0;
CharNo := 0;
if Assigned(pAse) then
begin
pAse.GetExceptionInfo(ExcepInfo);
pAse.GetSourcePosition(wCookie, LineNo, CharNo);
ErrString := concat(ExcepInfo.bstrSource, ' ',

ExcepInfo.bstrDescription, ' ',
'Line ', intToStr(LineNo),
'. Column ', intToStr(CharNo));
ShowMessage(ErrString);
end;
pAse := nil;
result := E_FAIL; { Halt script execution! }
end;
function TActiveScriptSite.OnEnterScript(): HResult;

begin
Result := S_OK;
end;
function TActiveScriptSite.OnLeaveScript(): HResult;

begin
Result := S_OK;
end;
{ IActiveScriptSite Window Implementation. }

function TActiveScriptSite.GetWindow(
var Hwnd: THandle): HResult;
begin
{ ActiveX Scripting uses this to get a window handle from
our application. This allows the script engine to
display information on the interface, such as a
dialog box. }
Hwnd := Application.Handle;
Result := S_OK;
end;
function TActiveScriptSite.EnableModeless(
FEnable: WordBool): HResult;
begin
{ Causes the host to enable or disable its main window
as well as any modeless dialog boxes. We won't need
this for our demo. }
Result := S_OK;
end;
initialization
TComObjectFactory.Create(ComServer, TActiveScriptSite,
IID_IActiveScriptSite, 'ActiveScript Host', '',
ciMultiInstance);
end.
End Listing Two

DBNavigator
Delphi 3 / Code Insight
By Cary Jensen, Ph.D.
Insightful Delphi
Delphi 3’s Code Insight Feature
O ne of the most powerful features of Delphi 3’s editor is virtually unknown.

This feature, called Argument Value Lists, is part of Code Insight. This
month’s “DBNavigator” provides an introduction to Code Insight, including the
largely undocumented Argument Value Lists.
Code Insight is a powerful new feature of the 1) Code Completion

Delphi editor that provides additional online 2) Code Parameters
help for the various declarations visible from 3) Argument Value Lists
the unit you are editing. Code Insight is pos- 4) Code Templates
sible because Delphi is continuously parsing 5) Tooltip Expression Evaluation
your code in the background while you work.
So long as the statements you are entering Code Completion
can be parsed (and are more or less syntacti- Code Completion is a feature that generates
cally correct), Code Insight works to analyze and displays a list of the visible members of an
your code, as well as that in any unit you are instance or class reference. There are two
using. In fact, Code Insight doesn’t even advantages of Code Completion. First, it
require the source code (the .PAS file) — the reminds you which members (that is, fields,
.DCU file alone provides enough informa- properties, and methods) are accessible from
tion. This information is used to generate and your reference. Second, it permits you to select
display popup lists and hints, either when a member from this list to have the member
you pause for a moment (as with Code inserted automatically into the editor, rather
Completion), or when you specifically request than requiring you to type the entire reference.
it using shortcut keystrokes.
If you’ve used Delphi 3, you have no doubt
There are five basic features of Code Insight: encountered Code Completion. For example,
if you select File | New Application, add a but-
ton to the default form, add an event handler
to this button, then type a reference to an
instance of the form followed by a dot (the
member reference operator), Code Completion
displays the list shown in Figure 1.
By comparison, if you enter a reference to the

TForm1 class, rather than an instance of the
class, a slightly different list is displayed. This
list, shown in Figure 2, displays those mem-
bers that are visible from a reference to the
class itself.
As mentioned earlier, the list displayed by

Code Completion respects the visibility of the
Figure 1: If you pause after entering an instance reference, declared members of the class. For example,
Code Completion displays the members that are visible from the within a unit where the class TForm1 is
reference. declared, the list generated for an instance of
DBNavigator
Figure 2: Code Completion can also display the members Figure 3: Right-click the list displayed by Code Completion to
visible from a class reference. change its sort order.
the TForm1 class includes private declarations, because private dures, and functions that are visible from your unit. For
members are accessible within that unit. However, if the example, imagine you are typing the following into a unit that
TForm1 class is declared in another unit (and that unit is using the Dialogs unit:
appears in an appropriate uses clause for the unit you are edit-
if MessageDlg(
ing), Code Completion will display only the public and pub-
lished members of a TForm1 instance. Protected members are
only displayed when you are editing a method associated with Shortly after typing the open parenthesis, Code Parameters
the class within which they are declared, or a method in a will display the syntax of the parameters of this function, as
class that descends from the one in which they are declared. shown in Figure 4. The parameter you are currently entering
Again, this corresponds to member visibility. is displayed in bold. If there is more than one parameter, the
bold type face in the Code Parameters window advances to
When you install Delphi 3, this list is sorted alphabetically by the next parameter as you complete each one.
default. You can, however, change the sort order by right-
clicking the list and selecting Sort by Scope, as shown in While Code Parameters, like Code Completion, is displayed
Figure 3. You can return to an alphabetically-sorted list by automatically, the Help window will be removed if you move
right-clicking and selecting Sort by Name. your cursor to another line of code. If this happens, you can
re-display the Help window by moving your cursor back to
Once the Code Completion list is displayed, you can have Code the argument list and pressing CSM.
Insight enter one of the listed members at your cursor by first
highlighting the desired member and then pressing J. There Argument Value Lists
are two ways to highlight a member. One way is to search incre- Argument value lists can be generated when you are entering
mentally. Specifically, begin typing the name of the member you an expression, such as the actual parameter in an argument
want. As you type, Code Completion will move through the list, list or the expression on the right side of an assignment state-
highlighting the member whose name most closely matches ment. Unlike Code Completion and Code Parameters, the
what you typed. The second technique is to use your cursor
keys, t, b, h, e, etc. You can use these techniques con-
currently. For example, you can begin by using an incremental
search to move to the general vicinity of a member in the list,
then use the cursor keys to select it. For obvious reasons, incre-
mental searching is usually only effective when the list is sorted
alphabetically.
You can cancel the list displayed by Code Completion by

pressing E. Furthermore, if you have an instance or object
reference and the Code Completion list is not currently dis-
played, you can force its display by pressing CM.
Code Parameters
The Code Parameters feature of Code Insight provides on- Figure 4: Code Parameters displays the syntax of the argument
the-fly syntax display for the arguments of methods, proce- list for a function, procedure, or method.

DBNavigator
Figure 5: Press CM to see the list of expressions valid in the Figure 6: Press CJ in the editor to display defined code
current context. templates.
Argument Value Lists feature must be specifically requested types). To change the sort order of the argument value list,
by pressing CM. The list generated displays the con- right-click the list and select the sort order you want.
stants, functions, and variables that are consistent with the
argument required by the expression. Code Templates
A code template is a pre-defined snippet of code that can be
I think this is the most powerful feature available in Code inserted into the editor at your request. For example, if you
Insight. Unfortunately — and ironically — it is unknown to want to enter an if statement, position your cursor at the
most Delphi developers. In fact, the section of the User’s location where you want the code template to be entered,
Guide that ships with Delphi 3 fails to even mention then press CJ. Code Insight displays a list of the existing
Argument Value Lists. I even attempted to locate some men- code templates, as shown in Figure 6.
tion of it in the online Help while writing this article, but
was unsuccessful. I know it must be in the online Help some- As with the argument value list, you can navigate this list of
where, because that’s how I learned of this feature (shortly code templates by using t, b, h, e, etc., or by con-
before Delphi 3 shipped). However, I am unable to locate a ducting an incremental, alphabetical search of the entries.
reference now. Once the template you want is highlighted, press J to
select it. Code Insight responds by entering the code, and
In any case, it is a Delphi 3 feature, and a powerful one at placing your cursor within it.
that. For example, imagine that while you are entering the
function MessageDlg you cannot recall which values are The code template list that appears when you press CJ
acceptable for the second argument, DlgType, which is of the has two columns. The first column contains the template
type TMsgDlgType. Such a situation is perfect for Argument description; the second column contains a shortcut, or
Value Lists. With your cursor poised to enter the second mnemonic, for the template. The shortcut contains no
argument, press CM. When you do, Code Insight gen- spaces, and must be unique for each template. For example,
erates and displays a list of the symbols that are visible to the shortcut for one of the if templates is ifeb. Once this list
your unit that match the data type of the required expression. of templates is displayed, you can perform an incremental
The list generated for the second argument of the MessageDlg search on the shortcut, use your cursor keys, or both. After
function is shown in Figure 5. you’ve highlighted the entry of the template you want, press
J to have Code Insight enter the template at the position
As with Code Completion, while the argument value list is of your cursor.
displayed you can begin typing the name of the symbol you
want, use your cursor keys to navigate the list, or both. Once If you know the shortcut associated with a particular code
the symbol you want entered at your cursor is highlighted, template, you can access the template directly by typing the
press J to have Code Insight enter the value. shortcut, then pressing CJ. If the characters of the short-
cut you have typed are unique to that shortcut, the code
Also similar to Code Completion, you can sort argument template is entered without the template list being displayed.
value lists alphabetically or by scope. In most cases it’s best to
have this list sorted by scope, because that will place all expres- If two or more shortcuts share the same characters as the one
sions of the matching type as required by the expression at the you entered, a short list of only those templates whose short-
top of the list. This is useful because the list not only includes cut names match what you have entered is displayed. For
symbols that match your expression exactly, but also includes example, if you enter if, then press CJ, the code tem-
any variants that are visible from your unit (because variants plate list contains all templates whose shortcuts begin with
are assignment-compatible with a wide range of expression “if ”, as shown in Figure 7.

DBNavigator
Figure 7: If you enter only part of a shortcut name, and that part Figure 9: Tooltip Expression Evaluation permits you to inspect
matches two or more templates, Code Insight displays a short list of the value of variables and properties at run time, without using
the matching template shortcut names from which you can choose. Run | Evaluate/Modify or setting watches.
Notice that the vertical bar ( | ) was placed where one or more
statements must be entered. The vertical bar character defines
where you want the cursor placed after the template has been
entered. If you now enter repeat in the code editor and press
CJ, the entire template will be entered, and your cursor
will appear on the line following the keyword repeat.
You can also easily modify existing code templates. To change

the name or description of a template, select the template in
the template list and select Edit. To change the text of the
template itself, select the template in the Templates list, then
simply modify the displayed code in the Code field.
The template text is written to an ASCII file named

delphi32.dci, which is stored in Delphi’s \Bin folder. If
you find that editing, adding, or deleting a template using
the Code Insight page of the Environment Options dialog
box is awkward, you can edit this ASCII file directly.
Figure 8: The Code Insight page of the Environment Options
dialog box. Tooltip Expression Evaluation
Tooltip Expression Evaluation is a feature of Delphi’s inte-
grated debugger. It permits you to easily inspect the value of
Creating Your Own Templates expressions at run time without having to resort to using
While Delphi ships with a number of useful code templates, Run | Evaluate/Modify, or setting watches. Instead, all you
you can easily add custom code templates. To do so, select need to do is position your mouse over an expression, and the
Tools | Environment Options from Delphi’s main menu. Next, value of that expression will be displayed in a fly-by window,
select the Code Insight page of the Environment Options as shown in Figure 9.
dialog box, as shown in Figure 8.
Sometimes the value of an expression is unavailable because of
To add a new template, select Add. In the Add Code Template compiler optimizations. If this is the case, the fly-by window will
dialog box enter a shortcut name and a description. Remember indicate the value is unavailable. You can reduce the likelihood of
that the shortcut name must be unique. Also keep in mind that this happening with Tooltip Expression Evaluation by un-check-
the incremental search of the template list is based on the short- ing the Optimization checkbox on the Compiler page of the
cut name. For example, click Add and enter the shortcut name Project Options dialog box. However, remember to turn compiler
repeat, followed by the description repeat statement. Press optimizations back on before testing and delivering your project.
J to continue. Now, within the Code field of the dialog box,
enter the following: Controlling Code Insight
The features of Code Insight are controlled from the Code
repeat
| Insight page of the Environment Options dialog box. Code
until expression; Completion, Code Parameters, and Tooltip Expression

DBNavigator
Evaluation are enabled and disabled using the checkboxes at the
top of this dialog box. If you disable either Code Completion or
Code Parameters, you can still access these Code Insight features
by pressing CM and CSM, respectively.
However, I know of no way to access Tooltip Expression
Evaluation if you disable this automatic feature. The Delay track-
bar permits you to control how long Code Insight waits before
automatically displaying the enabled Code Insight features.
Conclusion
Code Insight is a valuable new productivity tool for Delphi 3
developers. It can significantly reduce keystrokes, and the
time you spend in Delphi’s online Help. ∆
Cary Jensen is President of Jensen Data Systems, Inc., a Houston-based database

development company. He is author of more than a dozen books, including Delphi in
Depth [Osborne McGraw-Hill, 1996]. He is also a Contributing Editor of Delphi
Informant, and was a member of the Delphi Advisory Board for the 1997 Borland
Developers Conference. For information concerning Jensen Data Systems’ Delphi con-
sulting and training services, visit the Jensen Data Systems Web site at
http://idt.net/~jdsi. You can also reach Jensen Data Systems at (281) 359-3311,
or via e-mail at [email protected].

OP Tech
Delphi 3
By Adam Chace
What’s in the Package?

Design-time and Run-time Packages in Delphi 3
P ackages offer Delphi developers a new way to deploy applications with run-
time libraries. Forget the hassles of trying to incorporate VCL objects into
standard DLLs; with Delphi 3’s new packages feature, deploying shared
libraries of Delphi units and components is a cinch, and you don’t have to
change a single line of code. This article will provide an overview of what pack-
ages are, and how to use them.
Like standard DLLs, packages are essentially DLL. These libraries are used at design time
just bundles of code that are referenced by a by the IDE, and can then be incorporated
given application, be it an .EXE, an at run time by your application.
ActiveX control, a .DLL, or even another
package. Borland has given packages a The .DPL file isn’t the only file associated
.DPL extension to differentiate them from with a package, however. There’s also the
common DLLs, but their architecture is .DCP file, a single file collection of all the
almost identical to any implicitly linked DCUs your package contains; and the
.DPK file, the editor file that specifies
which .PAS files a particular package con-
tains, and which .DPL files a package
requires. The .DCP file is only of interest if
a package is distributed without source code
or the associated DCUs. In these cases, the
.DCP file is used when you compile your
package. The .DPK file is used any time
you edit a package, as we’ll soon see, and is
modified every time you add or remove
items to or from a package.
The New Component Palette Model

Although you may not know it, if you’ve devel-
oped in Delphi 3, you’re already using this new
feature. That’s because the VCL model has
been replaced with a new one, based entirely
on design-time packages. Design-time packages
are the new way of installing and removing
components in Delphi. The Delphi 3
Component palette is made up entirely of
design-time packages, which in turn, are collec-
tions of Delphi components and units. To con-
figure the palette, select Project | Options and
click on the Packages tab to display the dialog
Figure 1: Adding and removing design-time packages. box shown in Figure 1.
OP Tech
From this dialog box, you can load and unload packages of time package, or both), the package description, compiler
components without having to recompile your entire information, directory information, and other pertinent
Component palette (unlike previous Delphi versions). This is details about this particular package.
a major time saver, especially if you’re doing a lot of switching
between projects. You can also get a quick snapshot of what Using Non-package-based Components in Delphi 3
components a particular package contains by clicking on the Soon, most of your third-party components will be distrib-
Components button. Adding or removing packages is simply a uted in the form of design-time packages. But what about
matter of selecting the .DPL file you want by checking or your old components, or newer components that aren’t in
unchecking the box, and clicking Add or Remove. Once you packages? Can you still use these in Delphi 3?
add a new package, Delphi displays the message box shown
in Figure 2, telling you whether the package was successfully The answer, of course, is yes. Borland has provided an
installed, and if so, what components were added as a result. empty design-time package named DCLUSR30.DPL. Any
non-package-based component can be placed in it. To
From this dialog box, we can also edit any packages for place a component in this package, select Components |
which we have the .DPK file. If we highlight a package and Install to display the dialog box shown in Figure 4. All you
click Edit, we’ll see a dialog box that allows us to specify need to do is select your .PAS or .DCU file, and you’re
which components and units this package contains, as well done. As long as there are no errors in the code, the com-
as any other packages it requires (see Figure 3). This form ponent will install automatically as the package is loaded
also provides access to the package options (which allow us onto the palette.
to specify whether this package is a run-time or a design-
If you are adding DCUs this way, make sure they
were compiled in Delphi 3, because the DCU
architecture has changed. If you don’t have the
source code for a component that wasn’t com-
piled in Delphi 3, then you’ll be unable to install
the component into a package.
Running with Packages

Figure 2: Delphi tells what components the package has installed. That about covers design-time packages, which,
for the most part, were created to make configur-
ing the palette quicker and easier. Now, we get into the more
interesting topic of run-time packages. Run-time packages are
typically the same .DPL file as their design-time counterpart,
but are used in deployment rather than development. With a
typical Delphi application, all the necessary code for compo-
nents and units used in the application is compiled directly
into the executable, but this can produce a large executable
that can be tedious to update, especially if it is being done via
modem or the Internet. Building your project with run-time
packages allows you to reduce your update size at the cost of
a larger initial deployment. The initial delivery must include
your using application (.EXE, .DLL, etc.) and all the required
run-time packages. Once these packages are delivered, only
the using application needs to be updated, as long as no code
in the library files is changed.
Figure 3: Editing package contents.
Let’s see an example of the impact of using run-time pack-
ages. The application, PACK.EXE, was built as a single form
with a Label, Edit, DataSource, Table, ClientSocket, and
DBListBox component on it. Each of these components is
contained in a design-time package, and has a corresponding
run-time package (which again, is usually just the same file).
If we were to compile this application conventionally, we
would see it has a file size of 392,192 bytes (see Figure 5).
Now, we want to indicate that we will be distributing this appli-

cation not as a single executable, but rather as an executable
Figure 4: Installing “loose” components. with run-time packages. To do so, we select Project | Options
OP Tech
Figure 5: Our application compiled without using packages. Figure 7: The same application compiled with run-time
packages.
note that although a run-time package appears in the list, it will

only be required by the executable if it uses code contained in
that package. It isn’t necessary to go through this list and remove
those that you don’t think you need. The compiler takes care of
referencing the packages used for you. So, once we click Build, we
see the application is now only 13,312 bytes (see Figure 7)!
The next step is to determine which run-time packages

need to be distributed with this application. We can do this
in several ways:
Determine which design-time packages are used by your
application, and create a list of their corresponding run-
time packages.
Examine the application with an editor like Windows Quick
View, and note the .DPL files that are referenced in the file.
If it’s an .EXE or a .DLL, use a freeware tool like PFinder
to obtain the list.
Because we have built a simple Windows executable, we
can use PFinder to create the list, as shown in Figure 8.
Figure 6: Choosing to build with packages. (This free utility is available from Apogee Information
Systems, Inc., and can be downloaded from
and click the Build with runtime packages checkbox (see http://www.apogeeis.com/delphi.)
Figure 6). We can now, if desired, add or remove any run-
time packages from this list. Now, we simply need to deploy VCL30.DPL, VCLDB30.DPL,
and INET30.DPL once, with our executable. After that, as the
Why would we want to remove a package name from this project changes, we can update our 13KB executable. This is
list at this point? Say, for instance, we’re using a single especially helpful during the testing phase of a project, where
function in a single unit included in a large package. We you may be distributing new builds of an application daily.
may want to simply compile the code into the executable,
rather than deploy a sizable file for only one function. We Another benefit of using run-time packages is that a user-
may also know that we will be updating a particular com- machine, like standard DLLs, only needs one copy of any
ponent a great deal for this application. Because we ideally one package. So, if a project will be distributed as a suite of
want components and code in packages to be static, we using applications, you can save a lot of space by only
would avoid having to constantly update this .DPL file deploying the components they share once in a run-time
and the executable by removing the run-time package that package, rather than redundantly compiling the component
it’s contained in from this list. code into each using program.
Once you’ve decided whether you want to remove any files from That’s all there is to it. Run-time packages are an easy way to
this list, click OK, and build the application. It’s important to reduce your deployment costs, and you don’t need to make
OP Tech
Figure 8: PFinder package-listing utility.
any coding changes. In fact, you can decide to deploy with

run-time packages as late as your very last build, without hav-
ing to be concerned with the issues of conventional DLLs.
Conclusion
As we have seen, packages are an exciting new feature for
Delphi programmers to exploit. While design-time packages
streamline the use of the component library, run-time pack-
ages provide the real power. Delphi programmers can easily
segment and distribute portions of functionality, independent
of the .EXE file. This significantly reduces the amount of
effort involved with distributing application updates. ∆
Adam Chace is an Application Developer with Apogee Information Systems, Inc.,

a Boston-based consulting firm specializing in Delphi Client/Server systems. He
presented “Packages in Delphi 3” at the 8th annual Borland Developers
Conference in Nashville, TN and is a Delphi 3 Client/Server certified developer.
You can reach him at [email protected].

On The Net
Delphi 3 Client/Server Suite
By Keith Wood
Picture This on the Web

A CGI Program to Deliver Database Pictures
D elphi 3 makes the creation of Internet-capable programs even easier than

previous versions of Delphi. It contains basic classes that provide the nec-
essary functionality to produce applications that run as ISAPI or NSAPI exten-
sions, or as Common Gateway Interface (CGI) or Win-CGI executables.
This article explores the requirements for Delphi’s Web Components

generating a CGI program with Delphi 3. It Delphi 3 Client/Server Suite provides several
looks at the new Web module components, new components designed to ease the process
and how they interact with the HyperText of creating Web-aware programs. These com-
Transfer Protocol (HTTP) to create a docu- ponents, defined in the HTTPApp,
ment in response to a request. To show how ISAPIApp, CGIApp, and DbWeb units, are
this works, we’ll build a CGI program that described here. Their relationship to each
delivers pictures from a database. other is shown in Figure 1.
In a Web program, TWebApplication replaces

the normal application object. It must be
subclassed to handle the different versions of
Web extensions available. When its Run
method is called, it creates wrappers for the
incoming request and outgoing response,
before searching for a Web dispatcher to
translate between the two.
TWebModule is derived from TDataModule

via TCustomWebDispatcher, and so provides a
visual work area on which to develop our
application. On this form, we can add other
Web components and/or database-access con-
trols. Built into this component is the ability
to dispatch Web requests to different actions,
based on the additional path information that
accompanies the request. These are dealt with
by the Web action items.
A TWebActionItem is invoked by a TWebModule

when its particular path information is received
with a request. Having multiple action items in
our program allows us to respond differently to
requests that have some common basis. For
each action, we can specify the type of HTTP
On the Net
request to respond to, the extra path to look for, and whether it’s document internally, or the name of a file that provides this
the default for the module. Finally, we supply a handler for the text. References to substitution tags, delimited by the usual
OnAction event to actually construct the response. angle brackets and starting with a pound sign (#), can be
embedded in the document. Each tag has an identifier associ-
TWebRequest encapsulates an HTTP request that is received and ated with it, and these are used in the OnHTMLTag event to
processed by our program. It provides access to the details about provide the appropriate replacement text.
that request, including any parameters that are sent by the client.
This component is subclassed to allow the different types of TQueryTableProducer and TDataSetTableProducer provide an
Web extensions to retrieve the data in the appropriate way. easy way to generate an HTML table from the contents of a
query or table attached to a database. Its properties allow
TWebResponse allows us to easily send a reply. It has methods header and footer text to be specified, as well as control the
that accept the document we generate, and deliver it back appearance of the HTML table and its columns and rows.
through the Web server to the client. Input for the document For specialized formatting, the OnFormatCell event is used to
can be supplied as text, as a redirection, or from a stream. manipulate the cell contents even further, such as including a
Again, this component is subclassed to deal with the differing hypertext link.
ways of handling Web requests.
Using object-oriented techniques, Delphi 3 allows us to build
TPageProducer handles the generation of an HTML docu- a single Web-response program, and have it work with all the
ment in an easy-to-use manner. It contains the text of the standard extension formats: ISAPI/NSAPI, CGI, and Win-
CGI. All we need to do is change the Web module wrapper
and recompile.
Let’s put all of this together to produce a CGI application

that extracts a picture from a database record, and returns it
to the Web browser client.
Web Graphics
HTML documents define what appears on Web pages. It
consists of straight text, interspersed with formatting and
metadata commands (tags), which are delimited by angle
brackets (< >). These tags allow the specification of headings
and character and paragraph formatting, as well as define the
links that make the Web what it is.
Another tag allows images to be included on the page. The

graphics that are displayed this way are usually in one of two
formats (.GIF or .JPEG), but the images themselves are not
contained in the HTML document. The tag simply has a
reference to another Web document that provides the con-
tent. See Figure 2 for an example of an HTML page that
displays an image.
When the browser receives a document containing one of

these tags, it must send another request to retrieve the pic-
ture. To distinguish between the different document types
available on the Web, MIME (Multipurpose Internet Mail
Extensions) encoding is used. This includes a two-part type
to describe the contents of a document. Normal Web pages
have the type text/html, while the two standard image for-
Figure 1: The object model of new Web components.
mats are image/gif and image/jpeg, respectively. Web servers
<HTML> can be set up to automatically supply this content encoding
<HEAD> as part of the response to a client, based on the extension of
<TITLE>Sample Page</TITLE>
</HEAD>
the file requested.
<BODY>
<H2>Sample Page</H2> Usually, these images are stored in separate files on the Web
<P>This page displays a single image below:</P>
<IMG SRC="/images/Athena.jpg">
server. With a large site, managing these files can be diffi-
</BODY> cult. If, instead, we use a database to manage these pictures,
</HTML> then we need a way of extracting them again for delivery
Figure 2: Sample HTML referencing an image. over the Web.
On the Net
Field Name Format Comment table specifying the fields (see Figure 3), using the
PICTURE_NO AutoIncrement Unique id for each image Database Desktop tool. Save the table as WebPics.db.
PICTURE_TEXT Alpha 30 Description of the image
PICTURE_TYPE Alpha 30 The MIME type of the image To load appropriate pictures into the database, use the
PICTURE_BLOB BLOB The actual image WPLoad program that accompanies this article (see end
Figure 3: Fields in the demonstration table.
of article for download details). It allows us to browse
for files that contain .GIF or .JPEG images, and to
place these in the database with a description. The image type
Delivering Graphics is automatically extracted from the file, and is placed in the
To deliver a picture in response to a client request, we type field.
need to duplicate what the server would do with a file.
This means we must supply the document type, along with We also need to add an alias in the BDE to reference this new
other metadata, which describe the length of the response, table. The alias is WebPics, and its path is set to point to the
and indicate its beginning. After these headers, we send directory that contains the database table we just created.
the actual content of the image in its original binary for-
mat. Obviously, this comes from a BLOB field in the data- Building the Web Module
base table. The first step in creating our new Web module is to call on
the Web Server Application expert. To do this, select File |
For the purposes of this article, we’ll create a very simple New, and then the Web Server Application icon. Here, we are
database table that has the minimum fields necessary to asked what type of Web module we require. In this case,
effect delivery of the images. We’ll then generate a Paradox select CGI, and press OK.
{ Load details about a scheme from the registry. } if slsOtherParams.Count > 0 then
function TwmdWebPics.LoadScheme(sId: string): Boolean; Params.AddStrings(slsOtherParams);
begin Open;
end;
Result := True;
{ Find the required record and extract the image. }
with regSchemes do with Response, qryWebPics do
try try
if not OpenKey(sRegKey + '\' + sId, False) then sSelect := sBlobField;
Abort; if sTypeField <> '' then
sSchemeId := sId; sSelect := sSelect + ', ' + sTypeField;
sSchemeName := ReadString(sNameKey); SQL.Clear;
sAliasName := ReadString(sAliasKey); SQL.Add('SELECT ' + sSelect);
sUserId := ReadString(sUserKey); SQL.Add('FROM ' + sTableName);
sPassword := Coded(ReadString(sPasswordKey)); SQL.Add('WHERE ' + sKeyField + ' = ' +
slsOtherParams.Text := ReadString(sOtherKey); slsHTTPFields.Values['ID']);
sTableName := ReadString(sTableKey); Open;
sKeyField := ReadString(sKeyKey); try
sBlobField := ReadString(sBlobKey); ContentStream := TBlobStream.Create(
sTypeField := ReadString(sTypeKey); TBlobField(FieldByName(sBlobField)), bmRead);
except { Set image type. }
Result := False; if sTypeField <> '' then
end; ContentType :=
end; FieldByName(sTypeField).AsString
else
{ Extract a picture from the database and return it. } try
procedure TwmdWebPics.wmdWebPicswacGetPicAction( stmHeader := TStringStream.Create('');
Sender: TObject; Request: TWebRequest; stmHeader.CopyFrom(ContentStream, 0);
Response: TWebResponse; var Handled: Boolean); ContentStream.Position := 0;
var if Pos('JFIF',Copy(stmHeader.DataString,
sSelect: string; 1,10)) = 7 then
stmHeader: TStringStream; ContentType := 'image/jpeg'
begin else if Pos('GIF', Copy(
SetFields; stmHeader.DataString,1,10)) = 1 then
{ Check for valid scheme. } ContentType := 'image/gif';
if not LoadScheme(slsHTTPFields.Values['SCHEME']) then finally
Response.StatusCode := 400 stmHeader.Free;
else end;
begin except
{ Initialize database with scheme details. } StatusCode := 500;
with dbsWebPics do begin end;
AliasName := sAliasName; except
Params.Clear; StatusCode := 404;
if sUserId <> '' then end;
Params.Add('username=' + sUserId); end;
if sPassword <> '' then end;
Params.Add('password=' + sPassword);
Figure 4: Deliver a picture across the Web.

On the Net
We are presented with a blank Web module, wrapped in the substitution cipher, but a safer one could be used if
code appropriate for a CGI application. Place a Query com- deemed necessary.
ponent on the Web module, and enter the SQL code to
extract the image type and the BLOB field, selecting a para- To retrieve an image, we need two parameters with the
meter for the record id. request: the id of the scheme to use, and the id of the
record that holds the picture. On processing such a request,
Next, double-click on the Web module itself, or on its Actions we must first read the registry, using the scheme id to
property in the Property Inspector, to display the Web actions retrieve the other values. The connection ones are then
editor. Add a new action, give it a name, and mark it as the placed into a TDatabase object, and the database is opened.
default. On the Events tab in the Object Inspector, create a
handler for its OnAction event. Next, a query is constructed from the remaining values
and the record id. Once this is opened, we extract the
In this event, we execute the query with the id value image and its type, and return these to the client (see
passed in as a parameter (see the code in Figure 4). We Figure 4).
then attach the response to a stream created from the
BLOB field, and set the content type from the database As an added feature, if the image type field is not speci-
field. Some error handling caters for not being able to fied, we determine this from the picture itself. Each file
open the database table. If no record is found for that id, format has an identifying mark in its header. In the case of
then no image is returned. .JPEG files this consists of the characters JFIF at positions
7 through 10 (starting from 1), while .GIF files start with
HTTP requests can be submitted to this program in two the string GIF.
ways: GET or POST. In a GET request, the user’s parame-
ters are appended to the URL itself after a question mark Maintaining Schemes
(?). With a POST, the parameters arrive separately from Having the scheme details in the Windows registry makes
the URL. it more difficult to maintain them (as opposed to an .INI
file). So, we enhance the WebPics application to perform
Data passed in these ways end up in different properties of this maintenance task as well. This requires an extra Web
the Request object, both with the same structure. To ease action, added after double-clicking on the Web module
processing in the remainder of the program, we determine form, which we set to respond to the /config additional
which property is active, depending on the MethodType, path information.
and save a reference to it. All subsequent references to the
parameters then use this pointer: If no additional parameters accompany the request, we dis-
play a list of all the schemes the program currently knows
{ Set pointer to request fields depending on request method. }
procedure TwmdWebPics.SetFields;
about. This is achieved by using a TPageProducer component,
begin and responding to its OnHTMLTag event, to substitute for
if Request.MethodType = mtPost then the list of schemes. An HTML table is constructed in code to
slsHTTPFields := Request.ContentFields
replace the tag. If we were storing data in a database, we
else
slsHTTPFields := Request.QueryFields;
could use a TQueryTableProducer or TDataSetTableProducer
end; component, instead. To protect against later name changes,
we use the Request.ScriptName property to fill in the HTML
Generic Picture Delivery when referring to the program itself.
This works fine for our single database and its fields, but
what if we want this capability on any image in any database From this list of schemes, the user can select links that allow
table? We need to make the application more generic, and them to add a new scheme, update an existing one, or to
enable it to be configured for each specific case, without hav- delete one. The add and update options pass back a hidden
ing to recompile it. parameter-called action, which is set to Get.
To access a database, we need several pieces of information: Along with this, the id of the scheme to retrieve (or zero
the BDE alias, the user id, and a password. Furthermore, to when adding) is specified. This action parameter is looked for
access a table and extract an image, we require the names of in the program, which causes it to generate a page containing
the table, its key field, and the BLOB and image type fields. all the details for a single scheme, and allows these to be
altered. The pages come from two TPageProducer compo-
For this exercise, we store all this data in the registry. nents, where each page is set up as an HTML form. The
Under a common key, \Software\Kwood\WebPics, we forms’ actions call the program again, passing back the fields
maintain one key for each database scheme that we wish to for a scheme.
access. Within this key are the individual values for the
data identified above. To hide the password from prying After entering the requested data, the user sends the new
eyes, a coding scheme is used. In this case, it’s a simple details, which now arrive with an action of Add or Update,
On the Net
{ Accept request and perform configuration actions. }

procedure TwmdWebPics.wmdWebPicswacConfigureAction(
Sender: TObject; Request: TWebRequest;
Response: TWebResponse; var Handled: Boolean);
var
sAction: string;
begin
SetFields;
sAction := slsHTTPFields.Values['ACTION'];
{ Display a single scheme's details. }

if sAction = 'Get' then
begin
if slsHTTPFields.Values['ID'] = '0' then
Response.Content := wppAddScheme.Content
else if LoadScheme(slsHTTPFields.Values['ID']) then
Response.Content := wppUpdateScheme.Content
else
Response.StatusCode := 400;
end
Figure 6: The list of images from the database.
else
{ Apply changes to the registry (if applicable) and
redisplay complete list. }
begin
if sAction = 'Delete' then
DeleteScheme
else if sAction = 'Add' then
AddScheme
else if sAction = 'Update' then
UpdateScheme;
Response.Content := wppListSchemes.Content;
end;
end;
Figure 5: Configuring the database schemes.
these being the labels on the respective submit buttons. The

information is processed and stored in the registry.
If a delete link is selected (one for each scheme), the action

parameter reads Delete, and the id of the scheme is passed
along. The corresponding key in the registry is removed as Figure 7: Showing a single image from the database.
this request is processed.
The second action (see Figure 7), responding to the /single
Following an Add, Update, or Delete, the default action of additional path information, generates a page showing the
listing the schemes is performed again, ready for the next description of one image, its type, and the actual image
activity. All of this processing can be seen in the code in itself. It requires a parameter of the id for the record to be
Figure 5. displayed. In turn, it passes this on to the WebPics program
to extract the image from the database. Two TPageProducer
So, to initiate a maintenance session with the WebPics pro- components are used to present the standard page or an
gram, simply call it with the configuration directive attached: error page, as appropriate.
http://localhost/cgi-bin/webpics.exe/config.
To view the HTML for each page, simply use the View |
Demonstration Source option of your browser. The workings of this appli-
The WebPics CGI program is demonstrated through cation can be seen by looking at the code that accompanies
another CGI application: ListPics. This was constructed in this article.
the same manner as described above, and performs two
main actions. Conclusion
We’ve seen how we can create CGI Web applications using
The default action (see Figure 6), with no parameters, pro- Delphi 3’s new components. We’ve written a utility that can
duces a Web page that lists the description and image type deliver images out of a database and across the Web, as well as
for all the pictures in our database (up to a maximum of an application to access those pictures easily.
20). Each has a hypertext link attached to it that displays
that image on its own page. The bulk of this processing is Of course, just about anything can be stored in a BLOB field,
done by a TDataSetTableProducer component and its so this technique can be used to send sounds or even applets
OnFormatCell event. and programs.
On the Net
A large part of the future seems to be involved in providing
content through the World Wide Web. Of even more use is
Status Problems
the ability to interact with the client in deciding what data
While running this program through the WebSite Web
they want to see. Interpreting their requests, and constructing
server, and viewing it with Netscape, I kept getting an
an appropriate response, requires programming of some sort.
error message: “Unknown status reply from server: !0”.
Using a fully fledged programming environment such as
Delphi allows us to perform just about any action required to
Tracing the content sent from the Web server, it appeared
achieve this end. The new Web components of Delphi 3
that the HTTP header was being incorrectly sent. It was
make this even easier. ∆
going as: “HTTP/1.0 OK”, rather than the required:
The files referenced in this article are available on the Delphi “HTTP/1.0 200 OK”.
Informant Works CD located in INFORM\98\FEB\DI9802KW.
To overcome this, I needed to modify the source code for
the CGIApp unit. When sending the response in the
SendResponse method of the TCGIResponse component, I
altered the first header line to provide the format above:
{ The following line did not appear to work with WebSite
server, so I replaced it with the one immediately below.
AddHeaderItem(StatusString, 'Status: %s'#13#10); }
AddHeaderItem(HTTPRequest.ProtocolVersion + ' ' +
StatusString, '%s'#13#10);
Keith Wood is an analyst/programmer with CCSC, based in Atlanta. He started

This version is available in the code accompanying this
using Borland’s products with Turbo Pascal on a CP/M machine. Occasionally
working with Delphi, he has enjoyed exploring it since it first appeared. You can article, as unit CGIApp2.
reach him via e-mail at [email protected].
— Keith Wood

New & Used
By Alan C. Moore, Ph.D.
Abbrevia and LockBox

TurboPower’s New File/Data Manipulation Libraries
W hen we think of file/data manipulation, we generally think of the com-

mon operations of opening, saving, copying, deleting, and so forth. In
the changing world of information technology, two new operations must be
added to the list: encryption and compression. Of course, Delphi provides
excellent support for all the common operations, but practically none for the
last two.
Now, TurboPower has helped fill that void C++Builder) programmer can now add such
with two of its newest component libraries: support. Exactly what kind of support are we
Abbrevia, which provides support for work- talking about? Let’s see.
ing with PKZip-compatible files; and
LockBox, which supports the encrypting and Abbrevia supports the compressing and
decrypting of files. While the two libraries decompressing of files, adding them to, or
are quite different, there’s at least one situa- deleting them from, an archive, and view-
tion in which I can imagine using the two of ing the contents of an archive — all com-
them together: transmitting sensitive data mon operations. It also provides support
over the Internet. for some of the less common operations,
including creating a self-extracting archive
I’ll begin by discussing each of these libraries (an .EXE file that, when executed, extracts
separately, concentrating on their uses and all the archived files stored within it), and
their special features. Then I’ll examine some even compressing or decompressing on-the-
of the common features in both libraries. fly without saving to a file. Let’s take a
We’ll begin with Abbrevia, then turn our look at the components and classes that
attention to LockBox. make this possible.
The Many Ways to Zip Abbrevia consists of one visual component,

It’s difficult to imagine any pro- several non-visual components, and various
grammer reading this who’s not low-level support classes. For most applica-
familiar with compressed files, tions you can select one or more compo-
particularly PKZip files. That nents to provide the functionality you
particular application, or more need. When you need greater control, you
precisely collection of applica- can use the same support classes the com-
tions, is one of the great share- ponents use. The hierarchy of non-visual
ware success stories. So much so components is shown in Figure 1; the
that the PKZip-compression hierarchy of support classes is shown in
method has become the de facto Figure 2. Note that all the support classes
standard in the computer indus- are derived from TObject. TAbArchiveItem
try. Many applications, includ- describes a single file in an archive while
ing Norton Navigator for TAbArchive describes an entire archive.
Windows 95, now include sup- Both classes are abstract. Two useful classes
Figure 1: Abbrevia’s hierarchy of non- port for PKZip-compatible files. are descended from these: TAbZipItem and
visual components. With Abbrevia, any Delphi (or TAbZipArchive, respectively.
New & Used
Powerful and Flexible Power, Flexibility, and Ease of Use
Non-visual Components If, for some reason, you need or want to control the visual inter-
As you can see from Figure 1, face, the non-visual components we’ve been discussing so far
just about all the non-visual will meet your needs. However, Abbrevia’s TAbZipOutline com-
components are based on ponent makes it even easier to provide compression capabilities
custom components whose for your applications. It’s descended from TwinComponent, not
properties are defined but TOutline, to prevent access to some of the latter’s methods and
not published. This makes it properties that would be inappropriate here. It provides all the
Figure 2: Abbrevia’s hierarchy easy to derive your own spe- functionality of the TAbZipKit component along with an out-
of support classes. cialized components, but I line display appropriate for viewing and working with the files
doubt it would ever be nec- in a PKZip-compatible archive.
essary. As the name implies, TAbZipBrowser allows you to
inspect the contents of an archive, but not perform any other Figure 3, taken from one of the example programs, shows
operations, such as extracting or adding files. this component in use. There are a few more features of this
library I want to describe, particularly the low-level com-
Two derivatives of this component, TAbUnZipper and pression classes. I will postpone that discussion, however,
TAbZipper, provide the additional functionality. Both inherit until we look at the common features in Abbrevia and
useful properties from TAbZipBrowser, which
allow you to set the base directory for adding
and extracting files, the file name of the
archive itself, and the Items array that contains
the names of the files in the archive. There are
also several useful events. Particularly impor-
tant is OnProcessItemFailure, which allows you
to handle exceptions that arise in working with
files in an archive.
The extracting component, TAbUnZipper,

adds a few new properties related to extract-
ing files and using password protection. Its
method, ExtractFiles, takes care of the
drudgery of extracting the files from the
archive. Events such as OnConfirmOverwrite
and OnNeedPassword give you and your users
a good deal of flexibility in unzipping files. Figure 3: Abbrevia’s main example program showing all of the .ZIP file functionality.
The archive-building component, TAbZipper, adds new prop-

erties and events. The CompressionMethodToUse property
determines how files will be stored in an archive. The AutoSave
property controls when changes are made. The DosMode prop-
erty can be used to make an archive DOS compatible (restrict-
ed to DOS-compatible filenames). The AddFiles method
allows you to easily add files to an archive. Events such as
OnConfirmSave and OnRequestBlankDisk allow you to antici-
pate and handle a variety of file compression scenarios.
The last of the non-visual components, TAbZipKit, combines

the functionality of the previous two components and adds a
powerful new feature: the ability to work with hidden compres-
sion. What is hidden compression? It’s transparently compress-
ing an application’s data files upon exiting, and decompressing
them when the application is loaded. This technique would be
especially useful with large data files or with data files to which
the user needs to add password protection for security reasons.
We’ll be discussing data security in some detail shortly

when we examine the LockBox library, but first let’s take a
look at Abbrevia’s crowning glory: TAbZipOutline (see Figure 4: Abbrevia’s crowning glory, its visual component,
Figures 3 and 4). TAbZipOutline.

New & Used
Name Type Key Speed (in it takes to find the key by trying all the possi-
Size milliseconds) ble combinations? The manual discusses this
Triple Data Encryption Standard Block 128 360 issue in some detail. Byte magazine points out
Data Encryption Standard (DES) Block 56 270 that, while a 40-bit DES key could be cracked
Blowfish Cipher Block 128 250 in about 0.4 seconds, a 128-bit DES key could
LockBox Quick Cipher Block 128 210 take up to 157,129,203,952,300,000 years!
LockBox Cipher Block 128 160
Random Number Generator 64-bit Stream 64 120 Regarding the available options, Figure 5 doesn’t
Random Number Generator 32-bit Stream 32 70 tell the complete story. Each of the five block
LockBox Stream Cipher Stream 128 60 ciphers comes in two forms: one using
Figure 5: The ciphers available in LockBox. Electronic Codebook (ECB) mode and one
using Cipher Block Chaining (CBC) mode. While ECB is
slightly faster, CBC offers greater security because it uses the
encryption results from processing the previous block to process
the current block. Then we have the various stream modes.
All the stream methods are faster than the block methods.
The Triple Data Encryption Standard is by far the slowest
because it uses a 128-bit key and applies the DES encryption
algorithm to the data three times. Generally, block and stream
ciphers are appropriate for different programming situations:
Block ciphers work well with data in memory while stream
ciphers are ideal for operations involving files. I’ll have more
to say about the latter when I discuss the stream support in
LockBox and Abbrevia. The block ciphers are demonstrated
fully in the example program, ExLBox (see Figure 6). You can
use this program to test the relative speed of the various
methods. In addition to its many encryption methods,
LockBox also provides helpful programming choices.
Low or High: Choose Your Level

As with many of its other component libraries, TurboPower’s
LockBox provides you with the option of working with low-
level API routines or high-level classes. The low-level routines
Figure 6: LockBox’s example program, ExLBox, demonstrating
give you more control while the high-level classes make your
the use of block ciphers. work easier. The low-level routines fall into several groups:
GenerateXKey (where X is one of several key types)
LockBox. Now let’s put on our spy outfits and enter the allows you to generate the random key to use in
world of cryptography. encrypting/decrypting data.
InitEncryptX (where X can be any of the first seven
Data Security with LockBox basic encryption methods) allows you to prepare the
Like Abbrevia, LockBox provides many options and several lev- encryption system.
els at which you can work. Before starting this review, I wasn’t EncrytX (where X can be any of 13 encryption methods)
aware of the variety of data-encryption methods available. The allows you to encrypt or decrypt data.
methods in LockBox fall into two general groups: those using
block processing and those related to streams. Within these you LockBox provides high-level classes for working with memory
can choose from many encryption algorithms and key sizes, or file steams (which we’ll discuss soon) and high-level proce-
depending on the requirements of your application. Generally, dures and functions for working with any of its encryption
there is a tradeoff between the degree of security and speed of methods (stream based or block based). Some of the later rou-
execution. The tougher you make your data-encryption system tines encapsulate the functionality of the low-level routines we
to crack, the longer the data processing will take. looked at earlier, and add file-writing capabilities. Others allow
you to create your own key-generation procedure(s) using one
Figure 5 summarizes the different ciphers available in of several hashing algorithms. By now you should have a good
LockBox. You’ll notice a number of obvious patterns. While idea of the main features of both of these libraries. Now let’s
key size is one of the factors related to speed (the larger the discuss some of the common features of the two libraries.
key, the slower the processing), it’s by no means the only one.
Key size is also one of the main factors in ensuring security. Flowing with the Stream
You can’t decipher data without the key used to encrypt it. So As Ray Lischner points out in Secrets of Delphi 2 [Waite
the question becomes: What’s the maximum amount of time Group Press, 1996], streams are the preferred way of working
New & Used
Figure 8: A new sample program, ConfiZip, using components

Figure 7: The example program, CryptFile, demonstrating the from Abbrevia and routines from LockBox to encrypt and com-
use of stream ciphers. press confidential messages.
with files in Delphi. They give you the ability to work with a little of the history of data compression, its various methods,
data in memory and copy data structures from one medium and sources of additional information. In LockBox, you learn
to another (e.g. memory to file). Both these libraries take detailed information about the various encryption methods, the
advantage of this, and in doing so increase their value to us. importance of keys, and the uses for stream and block methods.
Again, there’s a list of references if you wish to learn more.
Abbrevia includes two routines (always used together) that
allow you to compress and decompress data without hav- As with TurboPower’s other libraries, Abbrevia and LockBox
ing to hassle with intermediary files. Using DeflateStream, include comprehensive online Help (mirroring the material in
you can save an application’s data files in compressed form the manuals), full source code, and excellent example programs.
when you, or your users, are finished with them, then load This company continues to provide free technical assistance
them again when needed. All this is handled transparently. and a 60-day, money-back guarantee for its products. You can
download a fully functional demonstration version of Abbrevia
Likewise, LockBox provides stream classes, which allow you from TurboPower’s Web site, and find out first hand if it meets
to save encrypted data to a file and later retrieve it using your needs. There’s no demonstration version of LockBox
one of six encryption methods. Figure 7 shows an example because some of its encryption methods are too powerful to be
program, CryptFile, that demonstrates the use of stream exported from the United States.
ciphers. Here again, the encryption is handled automatical-
ly and is completely transparent to the user. From a security Conclusion
point of view, it’s nearly impossible for anyone to make Using native Delphi classes and components, Abbrevia and
sense of the data stored in the encrypted file without first LockBox provide excellent com-
knowing the method used and the encryption key. pression and encryption func-
tionality for Delphi program-
As a bonus, I’ve included a sample program with this article, mers. Once again, TurboPower
ConfiZip, which uses components from Abbrevia and rou- demonstrates its leadership in
Abbrevia is an excellent collection of
tines from LockBox. It first encrypts a text file (using the third-party Delphi market- components and classes that provides a
Abbrevia’s built-in password dialog box) then saves the file in place. That leadership is based complete solution to working with PKZip-
compatible files. Its crowning glory,
compressed format. Naturally, the program also allows you to on meticulous attention to TAbZipOutline, allows you to easily work
with any of the files in an archive (e.g.
reverse this process. Figure 8 shows the layout of the main detail, excellent documentation, browsing, adding, or retrieving). LockBox
form; the code for the main form is given in Listing Three and responsiveness to the needs is a comprehensive collection of encryp-
tion/decryption classes and low-level rou-
(on page 37) and indicates how little programming is and wishes of customers. If you tines for adding data security to an appli-
cation. It includes a large number of
required to take advantage of these component/class libraries. need to add PKZip-compatible options to cover various programming sit-
(You can download all the source code and the 32-bit exe- compression or high-level uations and needs. Both libraries provide
support for Delphi streams, and come
cutable file: see end of article for details). encryption to your applications, with excellent documentation and exam-
ple programs. Abbrevia is available in a
I think you will be more than demonstration version. Both come with a
Other Common Features: Quality We’ve Come to Expect satisfied with these excellent 60-day, money-back guarantee.
TurboPower’s excellent tradition of documentation continues products. ∆ TurboPower Software Company

P.O. Box 49009
with these libraries. And, of course, the manuals include a full Colorado Springs, CO 80949-9009
Phone: (800) 333-4160 or (719) 260-9136
description of all the components (Abbrevia), classes, and low- The files referenced in this article Fax: (719) 260-7151
level routines. In addition, each manual provides an excellent are available on the Delphi Web Site: http://www.turbopower.com
Price: Abbrevia, US$199; LockBox, US$249
introduction to the area of programming it addresses, data com- Informant Works CD located in (available only in the US and Canada).
pression and data encryption, respectively. In Abbrevia, you learn INFORM\98\FEB\DI9802AM.

New & Used
if EncryptPassword = '' then
Alan Moore is a Professor of Music at Kentucky State University, specializing in Exit;
music composition and music theory. He has been developing education-related
applications with the Borland languages for more than 10 years. He has pub- ChDir(ExtractFilePath(Application.ExeName));
SaveDialog1.Title :=
lished a number of articles in various technical journals. Using Delphi, he spe- 'Enter Name of Text File to Archive';
cializes in writing custom components and implementing multimedia capabilities SaveDialog1.Filter := 'Text files (*.txt)|*.TXT';
in applications, particularly sound and music. You can reach Alan at
[email protected]. if SaveDialog1.Execute then
begin
if Pos('.', SaveDialog1.FileName) = 0 then
SaveDialog1.FileName :=
Concat(SaveDialog1.FileName, '.txt');
Begin Listing Three — Unit ConfZipU; try

interface Memo1.Lines.SaveToFile(ChangeFileExt(
SaveDialog1.FileName, '.txt'));
uses finally
Windows, Messages, SysUtils, Classes, Graphics, Controls, end;
Forms, Dialogs, StdCtrls, Buttons, AbZipper, AbArcTyp,
AbZBrows, AbUnZper; with AbZipper1 do begin
BaseDirectory :=
type ExtractFilePath(SaveDialog1.FileName);
TForm1 = class(TForm) AbZipper1.Filename :=
Memo1: TMemo; ChangeFileExt(SaveDialog1.FileName, '.zip');
Label1: TLabel; EncryptedFile :=
EncryptAndCompressBtn1: TBitBtn; ChangeFileExt(SaveDialog1.FileName, '.xxx');
DecryptAndDecompressBtn1: TBitBtn; GenerateLMDKey(Key, SizeOf(Key), EncryptPassword);
BitBtn1: TBitBtn; LBCEncryptFile(SaveDialog1.FileName, EncryptedFile,
OpenDialog1: TOpenDialog; Key, 16, True);
SaveDialog1: TSaveDialog; AddFiles(SaveDialog1.FileName, 0);
AbUnZipper1: TAbUnZipper; Save;
AbZipper1: TAbZipper; end;
procedure EncryptAndCompressBtn1Click(Sender: TObject);
procedure DecryptAndDecompressBtn1Click( if MessageDlg('Delete Text File?', mtConfirmation,
Sender: TObject); [mbOK, mbCancel], 0) = idOK then
private DeleteFile(ChangeFileExt(SaveDialog1.FileName,
{ Private declarations } '.txt'));
EncryptPassword : string; end;
public end;
{ Public declarations }
end; procedure TForm1.DecryptAndDecompressBtn1Click(
Sender: TObject);
var var
Form1: TForm1; TextFile : string;
Dlg : TPassWordDlg;
implementation Key : TKey128;
EncryptedFile : string;
uses begin
Abdlgpwd, LbProc, LbCipher;
Dlg := TPassWordDlg.Create(Application);
{$R *.DFM} EncryptPassword := '';
procedure TForm1.EncryptAndCompressBtn1Click(Sender: TObject); try

var Dlg.ShowModal;
Dlg : TPassWordDlg; if Dlg.ModalResult = mrOK then
Key : TKey128; EncryptPassword := Dlg.Edit1.Text;
EncryptedFile : string; finally
begin Dlg.Free;
if (Memo1.text='') then end;
begin
MessageDlg('You haven't entered any text to save', if EncryptPassword = '' then
mtError, [mbOK], 0); Exit;
Exit;
end; OpenDialog1.Title := 'Open Zip File';
OpenDialog1.Filter := 'Zip files (*.zip)|*.ZIP';
Dlg := TPassWordDlg.Create(Application);
EncryptPassword := ''; if OpenDialog1.Execute then
begin
try TextFile := ExtractFileName(ChangeFileExt(
Dlg.ShowModal; OpenDialog1.FileName,'.txt'));
if Dlg.ModalResult = mrOK then EncryptedFile :=
EncryptPassword := Dlg.Edit1.Text; ChangeFileExt(OpenDialog1.FileName,'.xxx');
finally with AbUnZipper1 do begin
Dlg.Free; BaseDirectory :=
end; ExtractFilePath(OpenDialog1.FileName);
ChDir(BaseDirectory);

New & Used
Filename := OpenDialog1.FileName;
ExtractFiles(EncryptedFile);
GenerateLMDKey(Key, SizeOf(Key), EncryptPassword);
LBCEncryptFile(EncryptedFile, TextFile,
Key, 16, False);
end;
try
Memo1.Lines.LoadFromFile(TextFile);
finally
end;
end;
end;
end.
End Listing Three

TextFile
High Performance Delphi 3 Programming

High Performance Delphi 3 The chapter detailing drag- of an FTP server component,
Programming is a repackag- and-drop through the encapsulating the server side
ing of last year’s unfortu- Windows Shell interface, of the FTP protocol.
nately titled Kick Ass Delphi one of the holdovers from
Programming. Publisher the first edition, now acts as Jon Shemitz offers three
Keith Weiskamp explained a “point” to the following chapters — one with co-
that the original titles in the chapter’s counterpoint: author Ed Jordan — which
Kick Ass series met some implementation of a drag- are unrelated in content, but
resistance with stores’ buy- and-drop interface with go a long way toward
ing agents, making it diffi- OLE/ActiveX (whose code demonstrating the depths to
cult to get these valuable represents a much more ele- which Delphi can be
volumes into the hands of gant solution than that of plumbed in application
programmers. In this reti- its predecessor). The chap- development. to create a truly modern user
tled edition, a handful of ter also offers an excellent interface. The implementa-
new chapters have been introduction to OLE tech- The first chapter in the set tion of setup wizards and
added, and one has been nology. The author suggests details the building of a property sheets, both affect-
removed; however, the rest additional readings to help Fractal generator. The math- ing the same data objects, is a
of the text remains funda- develop a deeper under- ematics and use of assembler complex endeavor. By lead-
mentally the same. standing of the topic. functions make this a good ing the reader through sev-
Sunday afternoon project eral implementation choices
The reader will find no John Penman contributed that will result in a broader (and the traps associated
introductory Delphi or one new chapter in addition skill set. Chapter 9, the col- with each) the author indi-
Object Pascal material here; to the two chapters brought laborative effort of the two cates which methods pro-
the book’s intended user level from the older book. His authors, is a collection of vide the most elegant solu-
is accurately labeled as area of interest is in develop- ideas and problem solvers on tion. This chapter takes con-
Intermediate to Advanced. ing Internet applications various topics ranging from siderable study time, but the
The material and topics are using the Winsock API. The the inner workings of results are well worth the
spread evenly across this lead chapter develops TPersistent descendants, to work.
spectrum. Seven authors CsSocket, a wrapper compo- how to build a Delphi appli-
contribute to the work, with nent for Windows Sockets. cation that acts as its own The remaining chapters are
each exhibiting a vastly dif- This offers a good introduc- setup program, to streaming fundamentally unchanged
ferent style. tion to Winsock. The data to the Clipboard. The from the previous publica-
CsSocket component is used chapter is a good read filled tion. Terence Goggin opens
Jim Mischel authored four as the basis for the two fol- with possibilities that the up the Math Unit, and shows
useful chapters about lowing chapters, which programmer can file away some useful functionality that
advanced utility topics; the describe a pair of FTP com- until needed. lacks documentation and
first three of these appeared ponents providing both popular usage. Bugs are iden-
in the book’s previous edi- client and server functionali- A new chapter entitled tified, and a clever way of
tion. Chapters covering con- ty. The FTP client was ini- “Models, Views, and Frames” handling dynamic data and
sole applications and the tially presented in the first is one argument for adding static arrays is explained in
development and use of edition; utilizing the CsSocket this volume to your library the course of developing a
DLLs are must-reads for component, it can stand even if you possess the earlier component that adds statisti-
consulting and commercial alone or be added to other edition. Mr Shemitz’s clear cal functions to a project.
developers. The explanations projects. Penman adds the explanation of utilizing Goggin also introduces build-
and examples are simple, and counterpart to the client frames and views to embed ing dynamic user interfaces.
provide a solid basis for fur- component in a new chapter one form inside another A single chapter by Richard
ther development. that details the development transmits the insight needed Haven explores Hierarchical

TextFile
Data and its representation. Working this concept from the
example of data contained in a relational database, the author
offers numerous techniques for viewing and navigation. Like a
few other chapters in the book, this topic requires dedicated
study, and has a limited and specialized audience.
Don Taylor writes the final four chapters in a style he pio-

neered with Delphi Programming Explorer. Readers are re-
introduced to Ace Breakpoint, a private investigator who
combines adventure noir with development exploration. This
unique text intersperses Mr Breakpoint’s adventures with
pages from his “casebook” of programming topics, which can
be integrated into a programmer’s repertoire: packing dBASE
and Paradox tables, floating toolbars, DLLs, and the
Windows 95 core, among others. While the narrative may be
an acquired taste, readers will find much useful information.
The CD-ROM that accompanies the book contains all the

examples listed in each chapter. The code compiled without a
problem in Delphi 3 — an improvement from the earlier edi-
tion, whose code contained many difficulties and errors associ-
ated with the transition from Delphi 1 16-bit to Delphi 2 32-
bit. The CD’s installation program, which moves projects to the
hard disk for compilation purposes, gives the reader a choice of
which demo programs to include.
A programmer’s library typically consists of two shelves: the

“tutorial and methods” collection, and the How to, Secrets of,
and High Performance collection. Books on this second shelf
help programmers solve problems and add depth to their
programming skills. If Kick Ass Delphi Programming is already
on that shelf, the reader should review the new material to
determine if it warrants the purchase price. Otherwise, this
well written and well organized collection of advanced devel-
opment information deserves a place in your programmer’s
library.
— Warren Rachele
High Performance Delphi 3 Programming, by Don Taylor, et al.,

Coriolis Group Books, 14455 N. Hayden Road, Suite 220,
Scottsdale, AZ 85260,
(602) 483-0192, http://www.coriolis.com.
ISBN: 1-57610-179-7
Price: US$49.99
(635 pages, CD-ROM)

File | New
Directions / Commentary
Packages
The Potentials and the Pitfalls
T he introduction of packages was one of the major changes in Delphi 3. Before packages, if you wanted
to work with a particular subset of the VCL, your options were somewhat limited. Of course, you could
create and load different versions of complib.dcl. However, this was a hassle, and rather wasteful of disk
space. With packages, those hassles are gone. Unfortunately, they’ve introduced a new set of problems.
But let’s start with the good news.
You Gotta Take the Good … installed on my system. I received the component could also be inadver-
In Delphi 3, if you select Component | following not-so-informative message: A tently installed by someone using a
Install Packages, you see all the packages device attached to the system is not property editor that is dependent
currently installed and the various working properly and the package can- upon it, but written and distributed
options you have: You can add a single not be installed (or something to that by someone else.
package or a collection of packages, effect). Because I knew what I had
remove packages, edit packages, and installed recently, I was able to un-check Leading vendors such as TurboPower
examine the components in a package. one or more packages, getting one to are now aware of the problems that can
If you encounter a problem or conflict work, but not both. arise with packages, and are taking
with a particular package, you can sim- aggressive steps to shield us from them.
ply de-select it by clicking the check Gradually, some sanity has emerged in That particular company, for example,
box. With the Package Editor you can how to work with packages. But this is giving each new product release a
create your own new packages, and with has more to do with the third-party slightly different package name from its
the Package Collection Editor you can developers’ commitment to correcting predecessor to avoid version conflicts. I
create collections of packages to distrib- the problem than with Borland’s lead- greatly appreciate such thoughtfulness.
ute to other developers. ership. Thanks to developers such as However, I can’t help but wonder if all
Ray Konopka, component writers now this could have been avoided in the
Delphi 3 Help points out that “design- have some guidelines to help them beginning if Borland had put as much
time packages ... simplify the tasks of avoid these conflicts. In Developing energy into warning us about the pit-
distributing and installing custom com- Custom Delphi 3 Components [Coriolis falls of packages as they did touting
ponents.” That’s true. When I first Group Books, 1997], Mr Konopka their advantages. What do you think?
installed third-party component imparts some excellent advice to the Let me know your views, experiences,
libraries in Delphi 3, I was amazed at developer who will be distributing problems, and solutions in working
how smoothly the process went. Once components in packages: with packages. ∆
the setup program was finished and I Always use a unique prefix in nam-
fired up Delphi 3, the new components ing your components to avoid con- — Alan C. Moore, Ph.D.
appeared, already installed on the flicts with components created by
palette. What a difference from Delphi other developers. Alan Moore is a Professor of Music at
1 and 2! Make sure your package names are Kentucky State University, specializing in
unique. music composition and music theory. He has
… with the Bad Never put property or component been developing education-related applica-
Unfortunately, I soon encountered editors in run-time packages; these tions with the Borland languages for more
problems: incompatibilities between belong only in design-time pack- than 10 years. He has published a number
packages from some of the third-party ages. of articles in various technical journals.
tool and component producers. These Make certain that the registration Using Delphi, he specializes in writing cus-
conflicts occurred because one product procedures are not in the compo- tom components and implementing multi-
depended upon components in the nent unit (as we’ve become accus- media capabilities in applications, particu-
other, but was using a different version tomed to doing), but in a separate larly sound and music. You can reach Alan
of those components than the one registration unit. Otherwise, your via e-mail at [email protected].

Delphi 3 Activex: A Handy Introduction

Uploaded by

Copyright:

Available Formats

Delphi 3 Activex: A Handy Introduction

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Delphi 3 Activex: A Handy Introduction

Uploaded by

Copyright:

Available Formats

February 1998, Volume 4, Number 2

Cover Art By: Tom McKeith

2 February 1998 Delphi Informant

3 February 1998 Delphi Informant

4 February 1998 Delphi Informant

M icrosoft has defined a lightweight subset of their OLE technology that is

This article demonstrates five aspects of converting a Delphi form into an

Importing an Existing ActiveX Control

The following example will demonstrate

6 February 1998 Delphi Informant

procedure TCalendarPage.EditChange(Sender: TObject);

The UpdateObject method is called when the ActiveX control

ActiveX controls by using the ActiveX Control Wizard, but

// Now find the right child position.

Figure 10: The Add To Interface dialog box.

opment environment by assigning a value to the Search

Because an ActiveX control is a DLL, you can’t directly

In our example, we would like to give the user a program-

F or advanced applications that require customization, a scripting language

The Scripting Engine

{ Initialize dispatch id. }

13 February 1998 Delphi Informant

Begin Listing One — ACTIVESCP.PAS SCRIPTTHREADSTATE_RUNNING = 1;

unit Activscp; { Thread IDs }

{ Interface specification for ActiveX Scripting. } const

SCRIPTITEM_ALL_FLAGS = (SCRIPTITEM_ISSOURCE + { Class IDs }

{ IActiveScriptParse.AddScriptlet() and type

15 February 1998 Delphi Informant

16 February 1998 Delphi Informant

ErrString := concat(ExcepInfo.bstrSource, ' ',

function TActiveScriptSite.OnEnterScript(): HResult;

function TActiveScriptSite.OnLeaveScript(): HResult;

{ IActiveScriptSite Window Implementation. }

End Listing Two

17 February 1998 Delphi Informant

By Cary Jensen, Ph.D.

O ne of the most powerful features of Delphi 3’s editor is virtually unknown.

Code Insight is a powerful new feature of the 1) Code Completion

By comparison, if you enter a reference to the

As mentioned earlier, the list displayed by

You can cancel the list displayed by Code Completion by

19 February 1998 Delphi Informant

20 February 1998 Delphi Informant

You can also easily modify existing code templates. To change

The template text is written to an ASCII file named

21 February 1998 Delphi Informant

Cary Jensen is President of Jensen Data Systems, Inc., a Houston-based database

22 February 1998 Delphi Informant

What’s in the Package?

The New Component Palette Model

Running with Packages

Now, we want to indicate that we will be distributing this appli-

note that although a run-time package appears in the list, it will

The next step is to determine which run-time packages

Figure 8: PFinder package-listing utility.

any coding changes. In fact, you can decide to deploy with

Adam Chace is an Application Developer with Apogee Information Systems, Inc.,

26 February 1998 Delphi Informant

Picture This on the Web