Borland's recently released Delphi 2.0 environment supports 32-bit applications, client/server development, team programming, and more.

June 01, 1996
URL:http://www.drdobbs.com/web-development/examining-borland-delphi-20/184409901

Examining Borland Delphi 2.0

Ted is president of Faison Computing, a firm that develops Delphi, C++ applications, class libraries, and software components for Windows. Ted can be reached at [email protected].

The Integrated Development Environment

Application development programs are expected to integrate the various phases of code editing, compiling, and linking. The Delphi IDE (see Figure 1) does this, and goes one step further. Because Delphi supports user-interface design with parallel code generation, it also has a Forms Designer that works in tandem with the Code Editor window. There is a button on the toolbar that lets you flip back and forth between a form's graphical view and its source code. If you add controls to a form, the code window is updated immediately and automatically.

Delphi projects usually entail multiple forms and code units, and Delphi makes it easy to manage the code units by keeping them all on a single tabbed window. Changing a unit is a one-click operation, and all the names of all open units are always visible on the tab bar. Most other programs employ the older MDI approach, where you switch between files using the Window menu.

The Delphi IDE is good but not perfect. With so many overlapping, independent windows sharing the screen--an Object Inspector, Code Editor, Forms Designer, main toolbar, and so on--the IDE can be a nuisance. I find it much easier to manage a single main window subdivided into moveable subpanes, as in Microsoft Visual C++ or even Borland C++ ClassExpert. The Object Inspector is nice for small projects, but inconvenient to use to get around in a larger project. (What might be nice is some kind of object-navigation outline pane, where you could see a complete hierarchy of all the objects in a project.)

The tabbed toolbar is nice, given the number of tools provided by Delphi. Because you can install your own tools, it is possible to run out of space on the toolbar, so Borland provided a set of scroll bars. You can also create new tabs on the tool bar, so you can organize your tools any way you want.

The integrated debugger also is easy to use. The tool bar has buttons to start, pause, step into, and step over code. A step out button is not available. You would use that button when you're single stepping inside a function and want to return to the calling function. Most IDEs have a step out command, including Borland C++. Why the Delphi team left it out is a mystery.

Something else I miss is an interactive tooltip for object inspecting at debug time. When you put a breakpoint in your code, you often want to inspect the value of a variable. Visual C++ pioneered the concept of tooltip inspection, where you move the mouse over a variable. If the variable is scalar and in scope, a tooltip window automatically appears, showing the variable's value. In Delphi, you have to right-click the variable, then chose the Evaluate/Modify command from the popup menu.

Delphi Reusability

Built-in Multithreading Support

For example, assume you have a form called TMyForm with a Start button to kick off some operation and an Abort button to terminate it. The operation itself will be performed by a class derived from the VCL class TThread, declared in Listing One. The Execute method, where your code gets invoked, overrides the virtual function by the same name in the base class. To use the new thread, you add an instance of it to the form or class that will control the thread; see Listing Two. To start the lengthy operation, you add a handler for the start button; see Listing Three. To abort the operation, you just call the thread's Terminate method in the handler for the form's Abort button; see Listing Four.

Programming at a High Level

Delphi uses VCL components to completely encapsulate the Windows API, providing a high-level programming interface. You might say that Delphi is to C++ what C++ is to C. The result is that you can get the job done much easier and with less code. Consider the process of drawing something on the screen. All Delphi components that are displayable inherit a method called Paint. You override this method and use a special Delphi Canvas object to draw on. Canvas is a high-level abstraction of a Windows device context. It handles all the drudgery of creating, selecting, deselecting, and destroying GDI objects for you. To draw a circle, for instance, you add a Paint method to your form or component and draw on the Canvas; see Listing Five.

You can change the attributes of the GDI objects, using simple assignment statements on their properties. To create a navy-blue pen, you use the statement Pen.Color := clNavy;. You don't even have to create the pen, because Delphi does it for you automatically. Because Color is a property of TPen, changing its value invokes an accessor function that takes care of perfunctory Windows details automatically.

Even though Delphi encapsulates the Windows API, you can still get under the hood to handle low-level or unsupported Windows features. If you want to hook the message dispatcher, a simple WndProc handler will take care of it. Say you want to intercept mouse clicks and typed characters for a form. The WndProc might look something like Listing Six. Calling the inherited method lets the base class Delphi handler process other events in the default way. Using a WndProc is considered a low-level message-handling scheme. For all Windows and internal Delphi messages, the proper way to install a message handler is through the message keyword. To add a handler for the WM_LBUTTONDOWN message, you add a class method like procedure WMLButtonDblClk(var Message: TWMLButtonDown); message WM_LBUTTONDBLCLK;.

Before adding a message handler to a class, make sure Delphi hasn't already provided an event-handler hook. For most commonly used messages and events, Delphi provides easy entry points, using the Events page of the Object Inspector. The Events page is usually the best way to add message handlers to a VCL component. To provide a handler that is invoked when your button is clicked, enter a handler name in the OnClick field. The handler can have any name you want. By double clicking the empty field, Delphi will create a default name, based on the event type and name of the control. Delphi creates an empty handler with correctly formatted arguments in the parameter list. Listing Seven is the default handler for the OnClick event. All event handlers are passed a pointer to the object that sent the message.

Database Support

For database programming, Delphi includes a complete set of VCL components to handle everything from simple table viewers to multiple-join queries to triggers and stored procedures. The heart of the architecture is the Borland Database Engine (BDE), which serves a role similar to the Microsoft ODBC Driver Manager. When developing database applications, you typically populate forms with a series of database-aware controls, like editboxes, listboxes, and grids. The TTable and TQuery components encapsulate the details of connecting with a database. A TDataSource component manages the mapping of database fields to data-aware components. Using a VCL navigator tool (which appears as a set of VCR buttons), you can move the cursor in the result set. Figure 2 shows the relationship between an application and database components.

All database access is through the BDE, including access to ODBC data sources. Compared to direct ODBC access, accessing ODBC data sources incurs a slight performance hit because of the pass-through of commands from the BDE DLL to the ODBC Driver Manager DLL. For operations that produce multiple records, the overhead is negligible. If your app makes lots of single-record operations, some degradation may be perceptible.

Access to all client/server SQL databases is through SQL Links, a Borland DLL that uses vendor-specific drivers to talk to the underlying databases. I tested Delphi with Oracle 7.2, the current version, using Personal Oracle. (InterBase is Borland's SQL database. It is a full 32-bit client/server database that competes against Oracle and Sybase SQL Server.) After getting Oracle running with Delphi, everything worked, although a real application will need to provide custom handlers for the multitude of database exceptions that may originate (otherwise Delphi will display opaque message boxes). Accessing Oracle data was just a matter of adding a TTable or TQuery component, sprinkling in a TDataSource, and putting database controls on a form. Oracle log-on was supported automatically. Delphi 2.0 is configured to work with Oracle 7.1, but I had to use the BDE Configuration Utility to change a number of low-level settings to get the BDE to work with Oracle 7.2.

While the Delphi side was easy, it took time to get the BDE to connect to an Oracle 7.2 database, mainly for lack of documentation of exactly what changes to make and where. I kept getting the message "Vendor Initialization failed: ORANT71.DLL". A call to Borland revealed that I needed to use the BDE Config tool to blank out the Server Name field, change the Net Protocol to the value "2," and alter the vendor init entry to ORA72.DLL. Yeah, I know, it should have been obvious....

User-Interface Development

Report Writing

Writing a Multithreaded Program

My multithreaded program, called "Bounce," has three objects bouncing around inside separate regions of a window. Each object is a black square with a colored body. As it moves, it leaves a black wake, eventually painting over the entire bounce region. Figure 3 shows how Bounce looks after running awhile.

Each object starts off in a random position, moving downward and to the right. When it hits the boundary of the enclosing region, it bounces off and continues. The Start and Stop buttons control the three threads. The Stop button suspends them, the Start button makes them resume. Each object is animated by a separate thread, implemented as a class derived from the VCL class TThread; see Listing Eight. The constructor for class TThreadBouncingObject randomizes the initial position for each bouncing object, and saves a pointer to the containment bounce region. The thread execution is carried out by the Execute method, which runs an infinite loop moving the object. At the end is a Sleep call, which suspends the thread briefly, to slow down the bouncing objects: On my 100-MHz Pentium, the objects were bouncing around so fast I couldn't tell what they were doing.

The main form creates three side-by-side regions of type TPanel, which are used as the containment boxes for the bouncing objects. The thread objects are created inside the FormCreate member, and destroyed in the FormDestroy member. These two functions are similar to regular constructors and destructors, except they are called as handlers by Delphi. The code for the main form is shown in Listing Nine.

Objects are created in two phases in Delphi. The declaration itself isn't enough, as in C++. You actually have to call an object's constructor to initialize it. The arrangement is similar to the way GDI objects are handled by Microsoft Visual C++, where you declare things like CPens and CBrushes, and subsequently must invoke their Create members.

Conclusion

For More Information

Figure 1: The Delphi IDE.

Figure 2: The architecture of a Delphi database application.

Figure 3: Running the Bounce program.

Listing One

TMyThread = class(TThread)
protected
    procedure Execute; override;
public
    constructor Create(your parameters} );
  end;

Listing Two

type
  TMyForm = class(TForm)
private
  LengthyOperation: TMyThread;
  end;

Listing Three

procedure TMyForm.StartButtonClick(Sender: TObject);
begin
  LengthyOperation:= TMyThread.Create( your parameter list);
end;

Listing Four

procedure TMyForm. AbortButtonClick(Sender: TObject);
begin
  LengthyOperation.Terminate;
end;

Listing Five

procedure TShape.Paint;
begin
  with Canvas do
        Rectangle(100, 100, 200, 200);
end;

Listing Six

procedure TMyForm.WndProc(var Message: TMessage);
begin
  case Message.Msg of
   WM_LBUTTONDOWN,  WM_CHAR:
      {do something}
      Exit;
  end;
  inherited;
end; 

Listing Seven

procedure TForm1.Button1Click(Sender: TObject);
begin
end;

Listing Eight

unit ThreadTest;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, 
  Controls, Forms, Dialogs, ExtCtrls;
type
  TThreadBouncingObject = class(TThread)
  private
    ContainmentBox: TPaintBox;
    BoundsCheckBox: TRect;
    P: TPoint;
    XIncrement, YIncrement: Integer;
    procedure UpdateScreen;
  protected
    procedure Execute; override;
  public
    constructor Create(Box: TPaintBox);
  end;
const
  WIDTH = 10;
  HEIGHT = 10;
implementation
{$R *.DFM}
constructor TThreadBouncingObject.Create(Box: TPaintBox);
begin
  inherited Create(True);
  ContainmentBox := Box;
  BoundsCheckBox := Rect(0, 0, Box.Width - WIDTH, Box.Height - HEIGHT);
  P.X := Random(ContainmentBox.Width - WIDTH);
  P.Y := Random(ContainmentBox.Height - HEIGHT);
  XIncrement := 1;
  YIncrement := 1;
end;
procedure TThreadBouncingObject.Execute;
begin
  repeat
    begin
      {update the X position}
      P.X := P.X + XIncrement;
      if (XIncrement > 0) and (P.X >= BoundsCheckBox.Right) or
         (XIncrement < 0) and (P.X <= BoundsCheckBox.Left) then
        XIncrement := -XIncrement;
        
      {update the Y position}
      P.Y := P.Y + YIncrement;
      if (YIncrement > 0) and (P.Y >= BoundsCheckBox.Bottom) or
         (YIncrement < 0) and (P.Y <= BoundsCheckBox.Top) then
        YIncrement := -YIncrement;
      UpdateScreen;
      Sleep(10); {pause briefly}
    end
  until Terminated;
end;
procedure TThreadBouncingObject.UpdateScreen;
begin
    ContainmentBox.Canvas.Rectangle(P.X, P.Y, P.X + WIDTH, P.Y + HEIGHT);
end;
end.

Listing Nine

unit TestForm;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  ExtCtrls, ThreadTest, StdCtrls;
type
  TForm3Threads = class(TForm)
    Panel1: TPanel;
    PaintBox1: TPaintBox;
    PaintBox2: TPaintBox;
    PaintBox3: TPaintBox;
    ButtonStart: TButton;
    ButtonStop: TButton;
    procedure FormDestroy(Sender: TObject);
    procedure ButtonStartClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure ButtonStopClick(Sender: TObject);
  private
    Object1: TThreadBouncingObject;
    Object2: TThreadBouncingObject;
    Object3: TThreadBouncingObject;
  public
    { Public declarations }
  end;
var
  Form3Threads: TForm3Threads;
implementation
{$R *.DFM}
procedure TForm3Threads.FormDestroy(Sender: TObject);
begin
  Object1.Terminate;
  Object1.Free;
  Object2.Terminate;
  Object2.Free;
  Object3.Terminate;
  Object3.Free;
end;
procedure TForm3Threads.ButtonStartClick(Sender: TObject);
begin
  Object1.Resume;
  Object2.Resume;
  Object3.Resume;
end;
procedure TForm3Threads.FormCreate(Sender: TObject);
begin
  Randomize;   {for the object initial positions}
  Object1 := TThreadBouncingObject.Create(PaintBox1);
  Object2 := TThreadBouncingObject.Create(PaintBox2);
  Object3 := TThreadBouncingObject.Create(PaintBox3);
end;
procedure TForm3Threads.ButtonStopClick(Sender: TObject);
begin
  Object1.Suspend;
  Object2.Suspend;
  Object3.Suspend;
end;
end.

Terms of Service | Privacy Statement | Copyright © 2024 UBM Tech, All rights reserved.