CODEWITHSUNDEEP
delphicomponents
wades
wades

Reputation: 947

Is it wise to create composite controls?

I have this application that reuses a sort of idiom in a number of places. There's a TPanel, and on it are some labels and buttons. The purpose is to allow the user to select a date range.

Here's an example of one such panel at runtime

The "&Dates" caption is one label, and the "All Dates" part is a second one. When the user clicks the "Choose" button a form pops up presenting the user with a pair of Date/Time controls and OK/Cancel buttons. If the user hits OK after selecting some dates, the 2nd label changes to "From mm/dd/yyyy To mm/dd/yyyy".

Is it plausible to create a component that packages up these controls? I have been looking at various resources for component writers and they don't seem to be pointed at the problems I am thinking about, such as handling the onclick events for the buttons. If this is a reasonable thing to attempt, I'd also appreciate pointers to descriptions of how to make such a "composite control."

Upvotes: 3

Views: 1734

Answers (4)

iamjoosy
iamjoosy

Reputation: 3349

Yet another way is to make the group of components a component template.

Upvotes: 2

Jeroen Wiert Pluimers
Jeroen Wiert Pluimers

Reputation: 24513

A very pragmatic way to develop composite controls is to use TFrame as a base for it.

That way, you can visually design your control, and either use events or inheritance

There are a couple of things you need to watch but all in all it is a much easier process than coding everything by hand (like some of the other answers suggest).

Things to watch for (not a complete list, but close):

  • don't forget the sprig
  • at design time (both in the TFrame and when putting the composite control on a design surface), sub-controls marked Visible=True are still visible. Two ways to solve this: Destroy those controls, or move them to an invisible region (Top/Left to minus values or to values bigger than Width/Height of the parent)
  • registering the TFrame descendent as a component where the TFrame descendent is also part of your project sometimes confues the IDE. Easy solution: call the TFrame descendent "TMyCustomControl", derive "TMyControl" from it, and register "TMyControl" as a component.

As a bonus, you don't have to remove the bevel/border and caption from the TPanel.

Upvotes: 2

RobS
RobS

Reputation: 3857

Yes, absolutely it is wise to build components like that because It saves a huge amount of coding.

Here is a guide to creating them semi-visually: How to Build Aggregate/Composite Components in Delphi

Essentially, the process outlined in this document is:

  1. Design the layout of your components inside a form in Delphi, placing all the components inside a TPanel (or a descendant thereof).
  2. Select and copy the panel and paste it into a text file.
  3. Replace all instances of " = " with " := ", and add a semi-colon to the end of each line.
  4. Convert all DFM "object" declaration lines to appropriate object constructor code, setting the parent of all visual controls to the container panel.
  5. Clean up any remaining code. Bitmaps will need to be placed in resource files.
  6. Place this new pascal code inside a create constructor for your component. Within the constructor , group object sections under the appropriate sub-component creator.

Where the document I think is wrong is that, for example, the example component is descended from a TPanel whereas to me it makes more sense to use TCustomPanel and expose only the methods you want to.

But it also explains how to add OnClick handlers etc.

the advantage of this method is that you get the layout of the components within the Panel done visually.

Upvotes: 5

bjaastad_e
bjaastad_e

Reputation: 711

It's reasonable, yes.

To create such a component, just derive a new class from for instance TCustomPanel, and add the sub-components as fields within the class.

Like this:

TMyDatePicker = class(TCustomPanel)
protected
  FChooseButton: TButton;
  FClearButton: TButton;
public
  constructor Create(Owner: TComponent); override; 
end;

constructor TMyDatePicker.Create(Owner: TComponent)
begin
  // Inherited
  Inherited;

  // Create Choose Button
  FChooseButton := TButton.Create(Self);
  FChooseButton.Parent := Self;
  FChooseButton.Align := alRight;
  FChooseButton.Caption := 'Choose';

  // Create Clear Button
  FClearButton := TButton.Create(Self);
  FClearButton.Parent := Self;
  FClearButton.Align := alRight;
  FClearButton.Caption := 'Clear';
end;

To add event handers, just add new protected procedures to your class.

For instance: 

procedure TMyDatePicker.HandleChooseButtonClick(Sender: TObject)
begin
  // Do whatever you want to do when the choose button is clicked
end;

Then connect the event handler to the OnClick event of the choose button (this should be done within the Create method of the class):

FChooseButton.OnClick := HandleChooseButtonClick;

There's a bit more to it than this, of course, such as fine tuning the alignments of the buttons and adding icons. Also you'll need to create your own events, such as OnDateSelected or OnDateModified.

But, apart from that, I think the above example should at least get you going. :)

Upvotes: 6

Related Questions