Ebook - Borland Delphi Component Writer Guide.pdf - Ebooki programowanie!!! WARTO !!! - alef01

Delphi Component Writer’s

Delphi for Windows

Introduction

Agreement

Delphi is not just a development environment for visually creating applications with

components. It also includes everything you need to create the components for building

applications in the same environment, using the same Object Pascal language.

The Delphi Component Writer’s Guide and its accompanying Help file (CWG.HLP)

describe everything you need to know to write components for Delphi applications. The

printed manual and the Help file contain the same information in different forms.

This material has two purposes:

1 To teach you how to create working components

2 To ensure that the components you write are well-behaved parts of the Delphi

environment

Whether you’re writing components for your own applications or for commercial

distribution, this book will guide you to writing components that fit in well with any

Delphi application.

What is a component?

Components are the building blocks of Delphi applications. Although most components

represent visible parts of a user interface, components can also represent nonvisual

elements in a program, such as timers and databases.

There are three different levels at which to think about components: a functional

definition, a technical definition, and a practical definition.

The functional definition of “component”

From the end user’s perspective, a component is something to choose from the palette

and use in an application by manipulating it in the Forms Designer or in code. From the

component writer’s perspective, however, a component is an object in code. Although

there are few real restrictions on what you can do when writing a component, it’s good

to keep in mind what the end user expects when using the components you write.

Before you attempt to write components, we strongly recommend that you become

familiar with the existing components in Delphi so you can make your components

Introduction 1

Guide

familiar to users. Your goal should be to make your components “feel” as much like

other components as possible.

The technical definition of “component”

At the simplest level, a component is any object descended from the type TComponent .

TComponent defines the most basic behavior that all components must have, such as the

ability to appear on the Component palette and operate in the Forms Designer.

But beyond that simple definition are several larger issues. For example, although

TComponent defines the basic behavior needed to operate the Delphi environment, it

can’t know how to handle all the specific additions you make to your components.

You’ll have to specify those yourself.

Although it’s not difficult to create well-behaved components, it does require that you

pay close attention to the standards and conventions spelled out in this book.

The component writer’s definition of “component”

At a very practical level, a component is any element that can “plug into” the Delphi

development environment. It can represent almost any level of complexity, from a

simple addition to one of the standard components to a vast, complex interface to

another hardware or software system. In short, a component can do or be anything you

can create in code, as long as it fits into the component framework.

The definition of a component, then, is essentially an interface specification. This

manual spells out the framework onto which you build your specialized code to make it

work in Delphi.

Defining the limits of “component” is therefore like defining the limits of programming.

We can’t tell you every kind of component you can create, any more than we can tell

you all the programs you can write in a given language. What we can do is tell you how

to write your code so that it fits well in the Delphi environment.

What’s different about writing components?

There are three important differences between the task of creating a component for use

in Delphi and the more common task of creating an application that uses components:

• Component writing is nonvisual

• Component writing requires deeper knowledge of objects

• Component writing follows more conventions

Component writing is nonvisual

The most obvious difference between writing components and building applications

with Delphi is that component writing is done strictly in code. Because the visual design

of Delphi applications requires completed components, creating those components

requires writing Object Pascal code.

2 Delphi Component Writer’s Guide

Although you can’t use the same visual tools for creating components, you can use all

the programming features of the Delphi development environment, including the Code

Editor, integrated debugger, and ObjectBrowser.

Component writing requires deeper knowledge of objects

Other than the non-visual programming, the biggest difference between creating

components and using them is that when you create a new component you need to

derive a new object type from an existing one, adding new properties and methods.

Component users, on the other hand, use existing components and customize their

behavior at design time by changing properties and specifying responses to events.

When deriving new objects, you have access to parts of the ancestor objects unavailable

to end users of those same objects. These parts intended only for component writers are

collectively called the protected interface to the objects. Descendant objects also need to

call on their ancestor objects for a lot of their implementation, so component writers

need to be familiar with that aspect of object-oriented programming.

Component writing follows more conventions

Writing a component is a more traditional programming task than visual application

creation, and there are more conventions you need to follow than when you use existing

components. Probably the most important thing to do before you start writing

components of your own is to really use the components that come with Delphi, to get a

feeling for the obvious things like naming conventions, but also for the kinds of abilities

component users will expect when they use your components.

The most important thing that component users expect of components is that they

should be able to do almost anything to those components at any time. Writing

components that fulfill that expectation is not difficult, but it requires some forethought

and adherance to conventions.

Creating a component (summary)

In brief, the process of creating your own component consists of these steps:

1 Create a unit for the new component.

2 Derive a component type from an existing component type.

3 Add properties, methods, and events as needed.

4 Register your component with Delphi.

5 Create a Help file for your component and its properties, methods, and events.

All these steps are covered in detail in this manual. When you finish, the complete

component includes four files:

1 A compiled unit (.DCU file)

2 A palette bitmap (.DCR file)

3 A Help file (.HLP file)

4 A Help-keyword file (.KWF file)

Introduction 3

Although only the first file is required, the others make your components much more

useful and usable.

What’s in this book?

The Delphi Component Writer’s Guide is divided into two parts. The first part explains

all the aspects of building components. The second part provides several complete

examples of writing different kinds of components.

Part I, “Creating components”

The chapters in this part of the book describe the various parts of components and how

you create them.

• Chapter 1, “Overview of component creation,” explains the basic steps involved in

the creation of any component. You should read this chapter before starting to create

components.

• Chapter 2, “OOP for component writers,” presents several topics component writers

need to know about programming with objects.

• Chapter 3, “Creating properties,” presents the procedures for adding properties to

components.

• Chapter 4, “Creating events,” describes the process of adding events to components.

• Chapter 5, “Creating methods,” explains the process of adding methods to

components and describes the conventions component writers should follow in

naming and protecting methods.

• Chapter 6, “Using graphics in components,” describes the aspects of the Delphi

graphics encapsulation that are particularly useful to component writers.

• Chapter 7, “Handling messages,” describes the Windows messaging system and the

mechanisms built into Delphi components to handle messages.

• Chapter 8, “Registering components,” presents the requirements for customizing

the way your components interact with the Delphi development environment,

including providing Help to component users.

Part II, “Sample components”

The chapters in this part of the book give concrete examples of making components.

• Chapter 9, “Modifying an existing component,” demonstrates the simplest way to

create a new component, by making modifications to an already-working

component.

• Chapter 10, “Creating a graphic component,” shows an example of how to create a

simple graphical component from scratch.

4 Delphi Component Writer’s Guide

• Chapter 11, “Customizing a grid,” shows how to create a component based on one

of the abstract component types in the component library.

• Chapter 12, “Making a control data-aware,” demonstrates how to take an existing

control and make it into a data-aware browsing control.

• Chapter 13, “Making a dialog box a component,” explains how to take a complete,

working form and turn it into a reusable dialog box component.

• Chapter 14, “Building a dialog box into a DLL,” shows how to take a form and its

controls and build it into a dynamic-link library (DLL) that any Windows application

can use.

What’s not in this book?

Although this book touches on all the aspects that define a Delphi component, it can’t

possibly cover every aspect of every kind of component you might want to write. If you

want to create a component that operates on any system at a low level, you need to

understand that system’s low-level operations.

For example, if you want to create components that take advantage of the intricacies of

the communications functions built into Windows, you need to know enough about

communications and the Windows API functions that implement them to make the

appropriate calls to those functions from within your component. Similarly, if you want

to access data in databases not directly supported by the Borland Database Engine, you

need to know how to program the interface for that database so your component can

provide access.

On the other hand, if all you want to do is create some slightly customized versions of

the standard components provided with Delphi, all you really need is a good working

knowledge of the Delphi development environment and its standard components, and

some fundamental programming skills.

Manual conventions

The printed manuals for Delphi use the special typefaces and symbols described in

Table Intro.1 to indicate special text.

Table Intro.1 Typefaces and symbols in these manuals

Typeface or symbol Meaning

Monospace type

Monospaced text represents text as it appears onscreen or in Object Pascal code.

It also represents anything you must type.

[]

Square brackets in text or syntax listings enclose optional items. Text of this sort

should not be typed verbatim.

Boldface

Boldfaced words in text or code listings represent Object Pascal reserved words

or compiler options.

Italics

Italicized words in text represent Object Pascal identifiers, such as variable or

type names. Italics are also used to emphasize certain words, such as new terms.

Introduction 5

Ebook - Borland Delphi Component Writer Guide.pdf

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: