[Delphi]Component gebruiken in een component

[Verwijderd]

Ik heb twee componenten. Deze twee componenten wil ik samenvoegen in 1 component. Niet de code copy/pasten, maar dat het andere component de events en de functies kan gebruiken van dat component.

Ik heb het al geprobeerd door hem gewoon toe te voegen, maar dat gaat niet werken.

Moet ik hem eerst createn of gaat dat vanzelf?

[Tomatoman]

Wat bedoel je precies met samenvoegen? Wil je zelf een nieuw component programmeren? En wat bedoel je precies met een component 'toevoegen'?

Misschien bedoel je dat twee componenten dezelfde code voor een bepaalde event gebruiken, bijvoordeeld de OnClick event van een TButton. In dat geval moet je de de object inspector gewoon voor beide componenten dezelfde OnClick event selecteren.

Probeer alsjeblieft je vraag wat duidelijker te stellen.

[whoami]

Heb je het over bestaande componenten of zelf geschreven componenten?

Lees eens iets over inheritance enzo anders...

[Verwijderd]

Wat bedoel je precies met samenvoegen? Wil je zelf een nieuw component programmeren?

Ja ik wil zelf een nieuw component programmeren

En wat bedoel je precies met een component 'toevoegen'?

Ik wil gewoon die functies/events van dat component gebruiken in mijn eigen component.

Misschien bedoel je dat twee componenten dezelfde code voor een bepaalde event gebruiken, bijvoordeeld de OnClick event van een TButton. In dat geval moet je de de object inspector gewoon voor beide componenten dezelfde OnClick event selecteren.

Nee dat bedoel ik niet.

Probeer alsjeblieft je vraag wat duidelijker te stellen.

is het bovenstaande duidelijk genoeg ?

Heb je het over bestaande componenten of zelf geschreven componenten?

Ik wil de functies gebruiken van een component die al bestaat en niet door mijzelf geschreven is.
De functies gaan gebruikt worden door een component die door mij nog geschreven moet worden.

Lees eens iets over inheritance enzo anders...

ik wil die functies niet doorgeven maar gebruiken. Ik heb dit al geprobeerd maar het is mij niet gelukt.

In ieder geval bedankt

[curry684]

Op donderdag 03 januari 2002 21:05 schreef Avater het volgende:
ik wil die functies niet doorgeven maar gebruiken. Ik heb dit al geprobeerd maar het is mij niet gelukt.

Dan moet je:
• Protected inheritance, maar ondersteunt VCL volgens mij niet, of
• Aggregeren. Enjoy

[marcelk]

Op donderdag 03 januari 2002 21:10 schreef curry684 het volgende:

[..]

Dan moet je:
• Protected inheritance, maar ondersteunt VCL volgens mij niet, of
• Aggregeren. Enjoy

De VCL ondersteunt geen multiple inheritance.

[SchizoDuckie]

euhmm... je kan toch een ancestor opgeven

[Tomatoman]

Stel je hebt twee componenten, TRood en TBlauw. Je wilt een component TPaars maken, dat de methoden TRood.MaakRood en TBlauw.VerfBlauw gebruik. Is dat wat je wilt?

Als je wilt proberen een component te laten overerven van twee andere componenten, heb je pech. Dat kan namelijk niet.

De enige oplossing: laat TPaars overerven van TRood en schijf zelf de code voor de methode VerfBlauw:

code:

type
  TPaars = class(TRood)
  public
    procedure VerfBlauw;
  end;

implementation

procedure TPaars.VerfBlauw;
begin
  // Deze code moet je zelf schrijven
end;

Nu kun je zowel TPaars.MaakRood als TPaars.VerfBlauw aanroepen.

[SchizoDuckie]

Op donderdag 03 januari 2002 21:40 schreef tomatoman precies wat Papa_eend bedoelde

[curry684]

Op donderdag 03 januari 2002 21:21 schreef marcelk het volgende:
De VCL ondersteunt geen multiple inheritance.

Dat sowieso niet, maar er staat me ook iets van bij dat protected inheritance op eenzelfde manier het Delphi-RTTI mechanisme verneukt.

Weet ik niet zeker, maar het zou sowieso nutteloos zijn daar je dan properties als Parent, Align en Left/Top zou hiden voor de componentgebruiker. Beetje moeilijk tonen dan

De handigste oplossing is meestal om een eigen componentje te inheriten van TCustomPanel en dan de rest van de gewenste componenten hierin te aggregeren.

[Verwijderd]

Protected inheritance omzeilen [hier in TDBGrid]:

code:

type
  THackGrid = class(TDBGrid);
begin
  THackGrid(MyDBGrid).SomeProtectedMember(..);
end;

Je kunt bij de protected members van een class die in dezelfde unit gedeclareerd worden; prefix 'Hack' is historisch bepaald

2 componenten combineren:

code:

TCombo = class
private
  FComp1: TComp1;
  FComp2: TComp2;
public
  constructor Create; virtual;
  destructor Destroy; override;

  procedure DoeIets;
end;
[..]
constructor TCombo.Create;
begin
  FComp1 := TComp1.Create;
  FComp2 := TComp2.Create;
end;

destructor TCombo.Destroy;
begin
  FComp1.Free;
  FComp2.Free;
  inherited;
end;

procedure TCombo.DoeIets;
begin
  FComp1.DoeIets;
  FComp2.DoeOokIets;
end;

Maar dit is vrij simpel, misschien bedoel je iets anders? 2 visuele componenten combineren ofzo?...

[Verwijderd]

Allemaal bedankt. Het is me gelukt.


Code ziet er nou zo uit:

code:

unit componenttest;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,Commdrv32;

type
  TTest = class(TComponent)
  private
    CommPortDriver1: TCommPortDriver;
  public
    constructor Create();  virtual;
    destructor  Destroy(); override;
    procedure   Connect();
    procedure   CommPortDriver1ReceiveData(Sender: TObject;
              DataPtr: Pointer; DataSize: Integer);
  end;

procedure Register;

implementation

constructor TTest.Create();
begin
  CommPortDriver1:=TCommPortDriver.Create(self);
end;

destructor TTest.Destroy;
begin
  CommPortDriver1.destroy;
end;

procedure TTest.Connect();
var test:boolean;
begin
  test:=CommPortDriver1.Connected;
end;

procedure TTest.CommPortDriver1ReceiveData(Sender: TObject;
  DataPtr: Pointer; DataSize: Integer);
  var test:integer;
begin
  test:=Datasize;
end;

procedure Register;
begin
  RegisterComponents('Standard', [TTest]);
end;

end.

[Verwijderd]

Ik weet niet of dit jouw echte code is, maar dit gaat iig wat beter werken

code:

  TTest = class(TComponent)
  [..]
    constructor Create(AOwner: TComponent); override;
    destructor  Destroy; override;
  [..]
  end;

[..]
constructor TTest.Create;
begin
  inherited;
  CommPortDriver1:=TCommPortDriver.Create(self);
end;

destructor TTest.Destroy;
begin
  CommPortDriver1.destroy;
  inherited;
end;

Conventie is om de private vars met een F te laten beginnen, maar dat moet je natuurlijk zelf weten...

[Verwijderd]

Ah ja nu wordt tie afgeleid. Thanx

[Verwijderd]

Om even op dit onderwerp door te gaan, hoe zit het met de events?

Stel dat we een eigen component maken die een TTimer bevat:

code:

type
  TMyClass = class(TComponent)
    private
    FTimer: TTimer;
    public
    constructor Create();
    destructor Destroy();

    property Timer: TTimer read FTimer write FTimer;

    published
    //..
end;

constructor TMyClass.Create();
begin
  inherited;
  FTimer := TTimer.Create(self);
end;

destructor TMyClass.Destroy();
begin
  FTimer.Free;
  inherited Destroy;
end;

De properties van de Timer zijn goed te benaderen, maar hoe kan het event onTimer worden afgevangen?

[JapJap]

Zoiets:

code:

type
  TMyClass = class(TComponent)
    private
    FTimer: TTimer;
    procedure OnTimer(Sender: TObject);
    public
    constructor Create();
    destructor Destroy();

    property Timer: TTimer read FTimer write FTimer;

    published
    //..
end;

constructor TMyClass.Create();
begin
  inherited;
  FTimer := TTimer.Create(self);
  FTimer.OnTimer := OnTimer;
end;

destructor TMyClass.Destroy();
begin
  FTimer.Free;
  inherited Destroy;
end;

procedure TMyClass.OnTimer(Sender: TObject);
begin
  ...
end;

Een gebruiker van het TMyClass component kan de OnTimer nu echter wel weer wijzigen!

[Tomatoman]

Om een object te vernietigen roep je Free aan, nooit Destroy. Door direct Destroy aan te roepen kan het zijn dat belangrijke code niet wordt uitgevoerd. Bovendien gaat MyObject.Free altijd goed, zelfs als MyObject nil is.

code:

destructor TTest.Destroy;
begin
  CommPortDriver1.Free; // NIET:  CommPortDriver1.destroy;
  inherited;
end;

[Delphi32]

Op woensdag 20 februari 2002 00:29 schreef tomatoman het volgende:
Om een object te vernietigen roep je Free aan, nooit Destroy. Door direct Destroy aan te roepen kan het zijn dat belangrijke code niet wordt uitgevoerd. Bovendien gaat MyObject.Free altijd goed, zelfs als MyObject nil is.

Een (heel) kleine aanvulling: MyObject.Free geeft geen AV als MyObject (als pointer) een waarde heeft OF nil is. MyObject.Free gaat echter grandioos de mist in als MyObject nooit gecreëerd is maar puur uninitialized. Doe maar eens het volgende: form maken, button plaatsen, OnClick definiëren als volgt:

code:

procedure TForm1.Button1Click(Sender: TObject);
var
  MyApplication: TApplication;
begin
  MyApplication.Free;
end;

Omdat MyApplication hier een local variable is, wordt deze niet geïnitializeerd naar nil, maar heeft een ongedefinieerde waarde. Het aanroepen van Free mag dus, maar het heeft tot gevolg dat een stukje geheugen vrijgegeven wordt alsof het een TApplication object betrof... dat geeft leuke resultaten. Bij mij viel mn keyboard ineens uit op die manier

[Nibble]

variabelen als commando's misschien ?