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:

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:

Delphi-Quellcode:

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.

:arrow: 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;

[Flocke]

Du könntest die OnCreate-Methode als Parameter des Konstruktors übergeben (oder eines alternativen überladenen), also

Delphi-Quellcode:

constructor Create(AOnCreate: TMyEvent);

[kolbaschedder]

Delphi-Quellcode:

TKlasse = class(TComponent)  <---- Hier ändern
private
  FOnCreate: TMyEvent;
  // bla
public
  // bla 
  constructor Create;override; <----- das muss geändert werden
published  <----- und vorallem das
 property OnCreate: TMyEvent read FOnCreate write FOnCreate;
end;

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

Du musst das ganze von TComponent ableiten, und über RegisterComponents (am besten in einem eigenen package) installieren. Danach kannst du die Komponente in der IDE verwenden.

Alle als published!! deklarierten Properties lassen sich dann über die IDE bzw., ObjectInspector verwenden

[Neutral General]

Zitat:

Zitat von Flocke

Du könntest die OnCreate-Methode als Parameter des Konstruktors übergeben (oder eines alternativen überladenen), also

Delphi-Quellcode:

constructor Create(AOnCreate: TMyEvent);

So hatte ich es auch schonmal aber wie soll das gehn? (Früher gings aber da sah mein ganzes System etwas anders aus)

Delphi-Quellcode:

abc := TDings.Create(abc.CreateDings); // abc.CreateDings gibts noch nicht

Wenn ich TDings.CreateDings als Parameter übergeben will dann willer nicht compilieren. Außerdem muss dann CreateDings public sein was ich auch nicht unbedingt will.

[Flocke]

Moment! Du willst die Methode deiner eigenen Klasse benutzen, um sie im Create dann wieder aufzurufen? Wofür machst du den ganzen Mist denn dann?

Wenn du das machen möchtest, was ich denke, dann definiere in der Basisklasse eine leere virtuelle Methode "AfterCreate", die im Konstruktor als allerletztes aufgerufen wird, und die du in abgeleiteten Klassen nach Belieben überschreiben kannst.

[sirius]

Ich glaube der General möchte sein eigenes kleines VCL-Package schreiben ohne die VCL von Borland zu nutzen :zwinker:

[Neutral General]

Zitat:

Zitat von sirius

Ich glaube der General möchte sein eigenes kleines VCL-Package schreiben ohne die VCL von Borland zu nutzen :zwinker:

Psssst das is doch noch streng geheim :shock: :mrgreen:
Naja aber so könnte man es fast bezeichnen. sirius hat nicht ganz unrecht ;)

[hermannhass]

Ich würde die afterconstruction-procedure ableiten
also
im Interface
Protected
procedure afterconstruction; override;


Und dann
procedure <class>.afterconstruction;
begin
inherited
if assigned(oncreate) then oncreate(self);
end;

Ist somit rein komponentenabhängig...
ist oncreate eine published property, kannst Du sie auch
im Objectinspector nutzen.
Bei Oncreate ist die dfm eines evtl. formulars schon gelesen.
ich glauve, dass ist genau, was du suchst....

[Neutral General]

Hi,

Hab nen Plan..RTTI.. Also nehmen wir an wir haben folgendes:

Delphi-Quellcode:

{$M+}
TDings = class(TKlasse)
published
  procedure FormCreate;
end;
{$M-}

kommt man jetzt an den Pointer zu der FormCreate procedure?
Ich hab es versucht mit

Delphi-Quellcode:

GetMethodProp(Self,'FormCreate')

:arrow:

Zitat:

---------------------------
Benachrichtigung über Debugger-Exception
---------------------------
Im Projekt Project1.exe ist eine Exception der Klasse EPropertyError mit der Meldung 'Eigenschaft FormCreate existiert nicht.' aufgetreten.
---------------------------
Anhalten Fortsetzen Hilfe
---------------------------

Das MUSS einfach mit der RTTI gehn! :X

Gruß
Neutral General

[sirius]

Das würde ja bedeuten, dass die Methode immer "FormCreate" heißen muss.
Ist ne Lösung, aber dann kannst du gleich AfterConstruction nehmen. Das wird auch automatisch nach Create aufgerufen (und ist in TObject erstmal leer)

[Apollonius]

Wie man an dem Namen GetMethodProp sieht, ist das ganze für Eigenschaften (nämlich Events) gedacht.
Aber was spricht denn bitte gegen eine virtuelle Methode? Selber Effekt, aber performanter, leichter zu verstehen und OOP-konform.