Probleme mit OnCreate Event

[Neutral General]

Hi,

Ich schreibe grad ne Klasse. Die soll ihr eigenes OnCreate Ereignis haben. Das Problem ist nur:

Delphi-Quellcode:

win.OnCreate := win.FormCreate; // Geht ja nicht
win := TForm1.Create(nil); // TForm1 <> class(TForm) !

im constructor würd ich dann halt sowas machen:

Delphi-Quellcode:

if Assigned(FOnCreate) then
  FOnCreate(Self);

Aber da ist FOnCreate natürlich nil.... Wie macht man sowas? Bzw wie macht die VCL das, das nach nem Doppelklick dann die entstandene FormCreate Methode dem Form.OnCreate zugewiesen wird. Weil das muss ja auch irgendwo passieren. Aber wo und wie?

Gruß
Neutral General

[kolbaschedder]

Hallo,

Das machst du direkt in deiner abgeleiteten Klasse. Du überschreibst den Constructor. Stichwort "override". Dort kannst du deine eigenen Initialisierungen machen. Das OnCreate-Ereignis ist eigentlich nur für den späteren "Verwender" der Klasse gedacht, damit er nicht selbst wieder ableiten muss.

Delphi-Quellcode:

  TMyClass= class(TForm)
  private
    frunning : Boolean;
  public
    constructor Create(AOwner : TComponent);override;
    destructor Destroy;override;
  published
  end;



constructor TMyClass.Create(AOwner : TComponent);
begin
  inherited Create(Aowner);
  ..... // Hier dein eigenes Zeugs
end;

MfG

Kolbaschedder

[Neutral General]

Zitat von kolbaschedder:

Hallo,

Das machst du direkt in deiner abgeleiteten Klasse. Du überschreibst den Constructor. Stichwort "override". Dort kannst du deine eigenen Initialisierungen machen. Das OnCreate-Ereignis ist eigentlich nur für den späteren "Verwender" der Klasse gedacht, damit er nicht selbst wieder ableiten muss.

Das ist mir auch klar
Aber genau das ist der Fall. Ich BIN der "spätere Verwender" der nicht selbst ableiten müssen soll/will

Gruß
Neutral General

[kolbaschedder]

Dann macht das aber eigentlich auch nicht viel Sinn.

Zitat:

Delphi-Quellcode:

win.OnCreate := win.FormCreate; // Geht ja nicht
win := TForm1.Create(nil); // TForm1 <> class(TForm) !

wäre ja dann eher sowas.

Delphi-Quellcode:

win := TForm1.Create(nil); // TForm1 <> class(TForm) !

win.FormCreate;

//oder bei einer eigenen Funktion das Objekt als Parameter
MyFormCreate(win);  // Hier deine Initialisierungen

[Neutral General]

Ich wills halt irgendwie machen wie die Forms aus der VCL.

Man klick doppelt drauf und hat sowas:

Delphi-Quellcode:

TForm1 = class(TForm)
  // bla
  procedure FormCreate(Sender: TObject);
private
  // bla
public
  // bla
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  DoSomething;
end;

Und diese FormCreate Methode wird in dem Moment wo ich Form1 erstelle diesem zugewiesen und ausgeführt.

Denn wenn ich sowas schreibe wie:

Form1 := TForm1.Create(nil); // egal ob das jetzt klappen würde.. geht um die theorie Dann würde mein FormCreate ausgelöst werden. So solls bei mir auch sein. Also woher weiß Form1 jetzt das es Form1.FormCreate benutzen soll? Wo wird das zugewiesen? Und wie macht man selbst sowas?

Gruß
Neutral General

[kolbaschedder]

Ok, jetzt wird'S langsam Klarer.

Wie du selbst gemerkt hast funktioniert das bei Formularen und Komponenten bzw., Controls auf Formularen. Die Zuordnung wird in den zugehörigen "*.dfm" Dateien gespeichert. wenn du die mal mit nem Texteditor aufmachst, findest du sowas

object Button1: TButton
Left = 8
Top = 40
Width = 73
Height = 57
Caption = 'start/stop'
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -16
Font.Name = 'Tahoma'
Font.Style = []
ParentFont = False
TabOrder = 0
OnClick = Button1Click <<------- Das ist die Zuweisung
end

Die Zuweisung geschieht dann während des Create über RTTI (RuntimeTypeInformation). kannst dir ja mal die RTTI.pas anschaun.
RTTI bietet eine universelle Schnittstelle zum Zugriff auf published!! deklarierte Properties.

MFG
Kolbaschedder

[Neutral General]

Mh..

Habs jetzt verstanden... Im constructor der Form wird u.a. der Code fürs OnCreate geladen bevor OnCreate dann aufgerufen wird.

Das bedeutet die einzige Möglichkeit wäre dann das OnCreate als Datei zu speichern und diese Datei als resource dem Projekt hinzufügen und dann im constructor muss ich das OnCreate aus der Resource laden und ausführen.

Wie speichert man Methoden?

[guidok]

Schau dir doch einfach mal die Quelltexte der VCL an. TForm findest du z.B. in der Unit "Forms".

Bei TCustomForm sieht das, was du willst so aus:

Delphi-Quellcode:

  TCustomForm = class(TScrollingWinControl)
  private
    FOnCreate: TNotifyEvent;
    ...
  protected
    procedure DoCreate; virtual;
    property OnCreate: TNotifyEvent read FOnCreate write FOnCreate stored IsForm;
    ...


procedure TCustomForm.DoCreate;
begin
  if Assigned(FOnCreate) then
  try
    FOnCreate(Self);
  except
    if not HandleCreateException then
      raise;
  end;
  if fsVisible in FFormState then Visible := True;
end;

In TForm (abgeleitet von TCustomForm) wird dann aus dem OnCreate ein puplished property gemacht.

Tip zum Finden der Quelltexte:

In deinem Quelltext mit der Maus auf den gewünschten Typen klicken z.B. TForm. Das Kontextmenü mit der rechten Maustaste aufrufen und den obersten Punkt "Deklaration finden" auswählen.

[kolbaschedder]

Naja fast,

der Code wird nicht gespeichert. Der existiert ja bereits in deinem Quellcode als Funktion. Nur die Zuweisung an die Eigenschaft OnCreate wird in der *.dfm gespeichert.

Wie gesagt ist die ganze Geschichte in allen Nachkommen von TComponent bereits integriert, funktioniert aber nur über die IDE. Die erzeugt ja dann auch die dfm-Dateien. Du kannst aber eigene dfm-Dateien laden über die Compileranweisung :

Delphi-Quellcode:

{$R *.dfm}  //so machst das die IDE

{$R meinDFM.dfm}  //so könntest du zusätzliche Sachen einbinden

Wie das genauer funktioniert, musst du aber jemanden Fragen, der sich damit auskennt.

MfG

Kolbaschedder

[Neutral General]

Naja ich hab ja kein Formular in dem Sinne..

Sagen wir ich habe sowas wie

Delphi-Quellcode:

TMyEvent = procedure of object; // nur als bsp.

TKlasse = class
private
  FOnCreate: TMyEvent;
  // bla
public
  // bla  
  constructor Create;
  property OnCreate: TMyEvent read FOnCreate write FOnCreate;
end;

constructor TKlasse.Create;
begin
  inherited Create;
  if Assigned(FOnCreate) then
    FOnCreate;
end;

So sieht das ganze ungefähr aus. Dann soll das ganze im Endeffekt so aussehn:

Delphi-Quellcode:

TDings = class(TKlasse)
  procedure CreateDings;
private
  //
public
  //
end;

procedure TDings.CreateDings;
begin
  ShowMessage('blaa');
end;

var Abc: TDings;
begin
  Abc := TDings.Create; // -> TDings.CreateDings wird ausgeführt (so stell ich mir das jedenfalls vor)
end;