More of this Feature • Page 1: Why, when, how • Page 2: New...component • Page 3: Raw Code • Page 4: Adding events • Download Demo Projects Printer friendly version

Join the Discussion "Post your questions, concerns, views and comments to this article..." Discuss!

Related Resources • Custom VCL development • VCL with source • Third party VCL • VCL using

   Standards in component writing
Finally we will cover a few more points about component writing, including some existing methods of base components, and standards for writing.

Creating and destroying your component:
Objects are created through a constructor and destroyed through a destructor.
The purpose of overriding a constructor is threefold
1. To create any objects that it contains within itself (sub objects)
2. To initialise values of the class (properties etc)
3. To raise an exception and stop the class from being created

It is standard to call the inherited constructor from within your own constructor so that the parent-class can perform its initialisations, although it is not necessary to do so in order to create your component. (Your component is created as soon as your constructor is finished, it is not created by calling the inherited constructor)

The purpose of overriding a destructor is simply to free any resources that were allocated during the life of component. Call inherited only after you have freed these resources.

Standard component parts:
Paint: You can override this method to provide your own custom drawing of your component.

Loaded: This is called at runtime by Delphi as soon as all of its properties have finished being set when its parent form is created. You can override this method in order to perform any actions that depend on a group of properties all being set.

Invalidate: Whenever a property is changed that affects the visual appearance of a component you should call this method.

ComponentState: This property is very useful when you need to check if your component currently exists at design/run time, or if its properties are currently being read by a streaming process.

Encapsulating your component properly:
It is standard to write your component as TCustomMyClass and then derive your component from that base class. The "custom" component you write will have most (if not all) of its properties / methods declared within its Protected section. When you descend from your "custom" class you simply redeclare your properties within the Public or Published sections.

type
  TCustomMyClass = class(TComponent)
  private
    FSomeString  : String;
  protected
    procedure SetSomeString(const Value : String); 
      virtual;
    property SomeString  : String
      read FSomeString
      write SetSomeString;
  end;

  TMyClass = class(TCustomMyClass)
  published
    property SomeString;
  end;

type
  TCustomMyClass = class(TComponent)
  private
    FOnStateChange : TStateChangeEvent;
  protected
    procedure DoStateChange(State : TState); virtual;
  published
    property OnStateChange : TStateChangeEvent
      read FOnStateChange
      write FOnStateChange;
  end;

procedure TCustomMyClass.DoStateChange(State : TState);
begin
  if Assigned(OnStateChange) then 
    OnStateChange(Self, State);
end;

Creating Custom Delphi Components >>
>> Part II.