Komponente klonen

[mitch01]

Hi,

wie kann man eine visuelle Komponente klonen?
Alle Eigenschaften der Ursprungskomponente sollen übernommen werden.
Jedoch ohne das ich die einzelnen Eigenschaften nach dem erstellen zuweisen muss.

Ich hab mir das so gedacht:

Delphi-Quellcode:

TMyClass = TComponent
 private
 
 public
 function Clone: TMyClass;
 end;

function TMyClass.Clone: TMyClass;
begin

  --> Result := Self.ErzeugeNeueInstanzVonMir; <--

end;

So nicht:

Delphi-Quellcode:

TMyClass = TComponent
 private
 
 public
 function Clone: TMyClass;
 end;

function TMyClass.Clone: TMyClass;
 var tmp: TMyClass;
begin
  tmp := TMyClass.Create;
  tmp.irgendwas := self.irgendwas;
  Result := tmp;
end;

Gibts dafür vielleicht irgendeine Funktion? Hat jemand eine Idee?

Danke für die Hilfe.
Gruß Mitch

[Stevie]

Hi Mitch,

du musst tatsächlich in deiner Klon-Funktion alle Eigenschaften kopieren, die übernommen werden sollen.

In der VCL gibt es an verschiedenen Stellen die Methode Assign. Diese weist dem Besitzer-Objekt die relevanten Eingenschaften des als Parameter übergebenen Objektes mit. Einen Automatismus gibt es meiner Meinung an dieser Stelle nicht.

MfG
Stevie

[Shaman]

Hoi

Lässt sich da nicht etwas mit Read/WriteComponent von TStream machen?

Gruss
Shaman

[Stevie]

Zitat:

Zitat von Shaman

Lässt sich da nicht etwas mit Read/WriteComponent von TStream machen?

Ich meine, dort werden auch Eigenschaften gespeichert, die man nicht übernehmen sollte (z.B. Name der Komponente)

[Shaman]

Dann ändert man die halt noch. Sind bestimmt nicht viele.

[mitch01]

Kommando zurück... hab das ganze über TStream versucht... das funktioniert soweit...

Nur bei erzeugen der neuen Komponente aus dem Stream werden plötzlich Eigenschaften nicht mehr erkannt und können der neuen Komponente nicht mehr zugeordnet werden, weil diese z.B. "Width" nicht enthält...

Hat das schonmal jemand gemacht... was könnte die Ursache sein?

[Stevie]

So funktioniert die Sache mit ner beliebigen Komponente (evtl. im initialization-Abschnitt die Klasse Registrieren):

Delphi-Quellcode:

function CloneComponent(Component: TComponent): TComponent;
var
  Stream: TStream;
  OldName, NewName: string;
  i: Integer;
begin
  Stream := TMemoryStream.Create;
  try
    OldName := Component.Name;
    i := 0;
    repeat
      Inc(i);
      NewName := RightStr(Component.ClassName, Pred(Length(Component.ClassName))) + IntToStr(i);
    until not Assigned(Component.Owner.FindComponent(NewName));
    Component.Name := NewName;
    Stream.WriteComponent(Component);
    Component.Name := OldName;
    Stream.Seek(0, soFromBeginning);
    Result := TComponentClass(FindClass(Component.ClassName)).Create(Component.Owner);
    Stream.ReadComponent(Result);
  finally
    FreeAndNil(Stream);
  end;
end;

MfG
Stefan

[mitch01]

Hi Stefan,

danke für die Antwort. Die Funktion funktioniert soweit, bis auf das er immer noch die Fehlermeldung bringt Klasse TMyClass nicht gefunden. Das funktioniert aber auch nicht mit einem TEdit. Da passiert das gleiche...

Noch ne Idee?

Gruß Mitch

[Stevie]

Delphi-Quellcode:

initialization
  RegisterClasses([TMyClass, TEdit]);

finalization
  UnRegisterClasses([TMyClass, TEdit]);

Edit: besser:

Delphi-Quellcode:

    {...}
    RegisterClass(TComponentClass(Component.ClassType)); 
    Result := TComponentClass(FindClass(Component.ClassName)).Create(Component.Owner);
    UnRegisterClass(TComponentClass(Component.ClassType)); 
    {...}

[punker76]

So gehts auch:

Delphi-Quellcode:

unit Unit1;

interface

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

type
  {* Die zu kopierende Klasse }
  TMyClass = class (TButton)
  public
    constructor Create (AOwner: TComponent);            override;
  end;

type
  TForm1 = class(TForm)
    Button1   : TButton;
    procedure Button1Click   (Sender: TObject);
    procedure FormCreate   (Sender: TObject);
  private
    MyButton   : TMyClass;
  end;

var
  Form1: TForm1;

implementation

{$R *.DFM}

//==============================================================================
constructor TMyClass. Create (AOwner: TComponent);
begin
  inherited Create (AOwner);
  Parent:= TWinControl (AOwner);
  Left   := 10;
  Top   := 100;
  Width   := 100;
  Caption:= 'Test Copy';
end;

//==============================================================================
//  Die Kopierfunktion
//==============================================================================
function Copy (AOwner: TComponent; ASource: TMyClass): TMyClass;
type
  TCopyClass = class of TMyClass;
var
  CopyClass   : TCopyClass;
begin
  CopyClass   := TCopyClass (ASource. ClassType);
  Result   := TMyClass (CopyClass. Create (AOwner));
end;

procedure TForm1. Button1Click (Sender: TObject);
var
  NewButton   : TMyClass;
begin
  {* nu kopier mal }
  NewButton      := Copy (self, MyButton);
  NewButton. Left   := MyButton. Left + MyButton. Width + 10;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  MyButton:= TMyClass. Create (self);
end;

end.

mfg :coder2: :coder2: :freak: :coder2: :coder2: :coder2:

[Stevie]

Jo, natürlich, aber du bist auf eine Klasse festgelegt!
Die Funktion oben kopiert eine beliebige Komponente. ;-)

[mitch01]

@ punker:
hi... danke...
du kopierst zwar die klasse, aber die eigenschaften der alten komponente werden nicht in die neue übernommen...
das ist aber die sache die unbedingt notwendig wäre... ansonsten würde ein Create auch reichen um eine neue instanz zu erstellen

@stefan:
deine funktion funktioniert soweit, das man 1 dimensionale Komponenten klonen kann

ich habe aber eine Komponente, geauer gesagt einen Frame mit Image, mehreren EditBoxen und Datenobjekten im Hintergrund.
Jetzt passiert folgendes:

bei

Delphi-Quellcode:

Result := TComponentClass(FindClass(Component.ClassName)).Create(Component.Owner);

wird das Objekt erzeugt mit allen Unterobjekten

und bei

Delphi-Quellcode:

Stream.ReadComponent(Result);

wird versucht die Unterkomponenten, (die ja eigentlich schon da sind), nochmal zu erzeugen, was natürlich wieder zum Fehler führt (Komponente mit Namen "Image" existiert bereits)

:wall: :wall: :wall:

gibts vielleicht noch ne andere Möglichkeit?

[Stevie]

Sag das doch gleich! :roll: :wink:
Ich hab etwas gebastelt, das funktionieren müsste, aber es ist - gebe ich zu - nicht die feine Art:

Delphi-Quellcode:

function CloneComponent(Component: TComponent): TComponent; 
var 
  Stream: TStream; 
  OldName, NewName: string; 
  i: Integer; 
begin 
  Stream := TMemoryStream.Create; 
  try 
    OldName := Component.Name; 
    i := 0; 
    repeat 
      Inc(i); 
      NewName := RightStr(Component.ClassName, Pred(Length(Component.ClassName))) + IntToStr(i); 
    until not Assigned(Component.Owner.FindComponent(NewName));
    Component.Name := NewName;
    Stream.WriteComponent(Component);
    Component.Name := OldName;
    Stream.Seek(0, soFromBeginning);
    RegisterClass(TComponentClass(Component.ClassType));
    Result := TComponentClass(FindClass(Component.ClassName)).Create(Component.Owner);
    while Result.ComponentCount > 0 do
    begin
      RegisterClass(TComponentClass(Result.Components[0].ClassType));
      Result.Components[0].Free;
    end;
    Stream.ReadComponent(Result);
  finally
    FreeAndNil(Stream);
  end;
end;

Das Komponenten-Löschen mache ich, damit sie nicht doppelt erstellt werden, wenn die Komponente aus dem Stream gelesen wird. Es geht auch besser, dann müsstest du aber selber ein Streaming entwickeln, das erst nachschaut, ob das gelesene Objekt bereits existent ist, und wenn ja, dann nur die Eigenschaften setzt. Irgendjemand hier hat so ein Streamingsystem mal entwickelt, such mal danach.

P.S.: :idea: Dieser Artikel über die RTTI dürfte dich sehr interessieren!

[mitch01]

Hey Stefan,

jetzt funzt es! :witch:

Allerdings kommt bei dem Aufruf:

Delphi-Quellcode:

Result := TComponentClass(FindClass(Component.ClassName)).Create(Component.Owner);

ein Fehler... jedoch kann ich das neue Objekt direkt erstellen :-) da ich ja weiß welchen Typ ich erstellen will.

Danke für deine Hilfe...