Eigene Klasse von TForm ableiten - Events

[NetSonic]

Hallo zusammen,

ich habe schon die Foren-Suche bemüht, aber für mich nicht das richtige gefunden. Vielleicht könnt Ihr mir ja einen bzw. den entscheidenden Tip geben:

Ich möchte eine eigene Form (TMyForm) von TForm ableiten und um ein weiteres Event ergänzen. Dieses soll ausgelöst werden, wenn der Aufruf SetMyParams(sAction) gemacht wurde. Wie muss ich das anstellen. Meine Klasse sieht bis jetzt wie folgt aus:

Delphi-Quellcode:

unit MyFormUnit;

interface

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

type
TMyEvent = procedure(Sender:TObject; sAction: String) of object;  
TMyForm = class(TForm)
  private
    { Private-Deklarationen }
    FOnSetMyParams: TMyEvent;
  property MyEvent:TMyEvent read FOnSetMyParams write FOnSetMyParams;
  public
    { Public-Deklarationen }
    procedure SetMyParams(sAction: String);
  end;

var
  MyForm: TMyForm;

implementation

{$R *.dfm}

procedure TMyForm.SetMyParams(sAction: String);
begin
if Assigned(FOnSetMyParams) then MyEvent(Self, sAction);
end;

initialization
  RegisterClass(TMyForm);

finalization
  UnRegisterClass(TMyForm);

end.

Aber das Ereignis wird nicht ausgelöst, obwohl ich auf die Prozedur SetMyParams zugreifen kann und die Klasse auch entsprechend vererbt wurde.
Ziel ist es, diese "neue" Formular-Klasse zu nutzen, um Programminterne-Ereignisse auszulösen. Also z.B. von einer anderen Form aus, auf SetMyParams zuzugreifen und eine Zeichenfolge zu übergeben, auf die ich dann im TMyForm-Event reagieren kann. Hoffe, mein Vorhaben ist soweit klar geworden?!

Danke.

Gruß
NetSonic

[DeddyH]

Die Property im private und deren Setter (der allerdings nicht zugewiesen wurde) im public-Abschnitt? Das kann ja nicht stimmen, oder?

[NetSonic]

Ok, das klingt plausibel. Aber was bedeutet für Dich jetzt zugewiesen bzw. wie müsste diese Zuweisung dann aussehen?

[DeddyH]

Ich hatte Dich zuerst falsch verstanden, aber wenn ich jetzt richtig denke, müsste es so funktionieren:

Delphi-Quellcode:

type
  TMyEvent = procedure(Sender:TObject; sAction: String) of object;

  TMyForm = class(TForm)
  private
    { Private-Deklarationen }
    FOnSetMyParams: TMyEvent;
  public
    { Public-Deklarationen }
    procedure SetMyParams(sAction: String);
    property MyEvent: TMyEvent read FOnSetMyParams write FOnSetMyParams;
  end;

var
  MyForm: TMyForm;

implementation

{$R *.dfm}

procedure TMyForm.SetMyParams(sAction: String);
begin
  if Assigned(FOnSetMyParams) then 
    FOnSetMyParams(Self, sAction);
end;

[NetSonic]

Also leider, passiert da nix. Ich habe das ganze wie folgt eingebunden:

Meine neue Klasse:

Delphi-Quellcode:

unit MyFormUnit;

interface

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

type
TMyEvent = procedure(Sender:TObject; sAction: String) of object;
TMyForm = class(TForm)
  private
    { Private-Deklarationen }
    FOnSetMyParams: TMyEvent;
  public
    { Public-Deklarationen }
    procedure SetMyParams(sAction: String);
    property MyEvent: TMyEvent read FOnSetMyParams write FOnSetMyParams;
  end;

var
  MyForm: TMyForm;

implementation

{$R *.dfm}

procedure TMyForm.SetMyParams(sAction: String);
begin
  if Assigned(FOnSetMyParams) then
    FOnSetMyParams(Self, sAction);
end;

initialization
  RegisterClass(TMyForm);

finalization
  UnRegisterClass(TMyForm);

end.

Der Abkömmling:

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TForm1 = class(TMyForm)
    Edit1: TEdit;
  procedure MyEvent(sAction: String);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.MyEvent(sAction: String);
begin
     MessageDlg(sAction, mtWarning, [mbOK], 0);
end;

//Wichtig!
//Abschnitt um die Formularklasse im Programm bekannt zu machen!!!
initialization
     RegisterClass(TForm1);
finalization
     UnregisterClass(TForm1);

end.

Und der Aufruf:

Delphi-Quellcode:

procedure TfrmMain.Button1Click(Sender: TObject);
begin
     Form1.Color := clRed;
     Form1.SetMyParams('TEST');
end;

Die Farbe wird verändert, aber mein Event wird nicht "gefeuert"...

[DeddyH]

Und wo wird der Property eine Methode zugewiesen?

Delphi-Quellcode:

MyForm := TMyForm.Create(nil);
MyForm.MyEvent := Methode; //das hier muss ja irgendwo stehen

[NetSonic]

Sorry, aber bei dieser Thematik raucht mir gerade der Kopf. Kannst Du das bitte anhand meines Sourcecodes verdeutlichen?
Ich möchte ja erreichen, dass, wenn ich Form1.SetMyParams('test') aufrufe, das Event MyEvent gefeuert wird, in dem ich dann die übergebene Zeichenfolge weiterverarbeiten kann... Und ich dachte, diese Methoden-Zuweisung muss ich nur in meiner eigenen Klasse machen, damit wiederum davon abgeleitete Klassen automatisch darauf Zugriff haben.

Und die Zuweisung habe ich doch hier gemacht, oder sehe ich das Falsch?!

Delphi-Quellcode:

FOnSetMyParams: TMyEvent;

[DeddyH]

Delphi-Quellcode:

procedure TfrmMain.Wuppdi(Sender:TObject; sAction: String); //muss natürlich als Methode deklariert sein
begin
  ShowMessage('Da schau her: ' + sAction);
end;

procedure TfrmMain.Button1Click(Sender: TObject);
var 
  test: TMyForm;
begin
  test := TMyForm.Create(nil);
  try
    test.MyEvent := Wuppdi;
    test.SetMyParams('TEST');
//    test.ShowModal;
  finally
    test.Free;
  end;
end;

[NetSonic]

In Ordnung, aber ich möchte auf das Ereignis nicht innerhalb von TfrmMain reagieren, sondern innerhalb von Form1. Halt wie z.B. mit OnShow oder ähnlichem. Die muss ich doch auch nicht noch extra zuweisen... Hoffe mein Vorhaben ist soweit verständlich!?

[DeddyH]

Wieso musst Du OnShow nichts zuweisen? Wenn Du im Objektinspektor nichts im OnShow einträgst, dann wird das Event ja auch nicht gefeuert.

[himitsu]

In der IDE, genauer gesagt im OI, klickt man z.b. doppelt auf ein Event und Delphi weist es zu.

Ob es nun "manuell" im Code oder automatisch über die DFM zugewiesen wurde, ist dabei egal ... aber irgendwo muß die Methode zugewiesen sein, denn sonst weiß Delphi ja nicht was es dort was machen soll.

[DeddyH]

Richtig, das ist ja der Sinn von Events: man kann bei definierten Ereignissen eingreifen. Wenn man das gar nicht beabsichtigt, kann man ja auch stumpf irgendeine fixe Methode aufrufen oder dergleichen.

[NetSonic]

Zitat:

Zitat von DeddyH (Beitrag 1102513)

Wieso musst Du OnShow nichts zuweisen? Wenn Du im Objektinspektor nichts im OnShow einträgst, dann wird das Event ja auch nicht gefeuert.

Sorry, Du hast natürlich recht. Hatte mich da falsch ausgedrückt.
Aber wie ist es dann jetzt möglich, dem Event eine Methode innerhalb von Form1 zuzuweisen? Ich möchte "Wuppdi" nicht auf frmMain nutzen, sondern innerhalb des Formular, welches auf TMyForm basiert... Wie muss ich das anstellen?

[DeddyH]

Du kannst dem Event doch jede kompatible Methode zuweisen, egal welchem Objekt sie gehört. Soll das aber immer dieselbe aus Deinem TMyForm sein, dann brauchst Du auch kein Event wie bereits erwähnt.

[NetSonic]

Jede abgeleitete Form soll aber anders auf SetMyParams reagieren. Und die folgende Zuweisung wird mir mit dem Fehler "Inkompatible Typen: TObject und string" vom Compiler quittiert:

Delphi-Quellcode:

Form1.MyEvent := Form1.MyEvent;
Form1.Color := clRed;
Form1.SetMyParams('TEST');

Delphi-Quellcode:

procedure TForm1.MyEvent(sAction: String);
begin
     MessageDlg(sAction, mtWarning, [mbOK], 0);
end;

[DeddyH]

Wenn Du schon selbst nicht mehr weißt, wie Du die Methode deklariert hast:

Delphi-Quellcode:

procedure TForm1.MyEvent(Sender: TObject; sAction: String); //Sender-Parameter muss dazu

[edit] Ich habe mal schnell ein Beispiel gebaut:

Delphi-Quellcode:

type

  TOnRenameEvent = procedure(Sender: TObject; NewName: string) of object;

  THund = class
  private
    FName: string;
    FOnRename: TOnRenameEvent;
    procedure SetName(const Value: string);
  public
    constructor Create;
    procedure ShowNewName(Sender: TObject; NewName: string);
    property Name: string read FName write SetName;
    property OnRename: TOnRenameEvent read FOnRename write FOnRename;
  end;

constructor THund.Create;
begin
  inherited;
  FName := 'Bello';
end;

procedure THund.SetName(const Value: string);
begin
  if Value <> FName then
    begin
      FName := Value;
      if Assigned(FOnRename) then
        FOnRename(self, FName);
    end;
end;

procedure THund.ShowNewName(Sender: TObject; NewName: string);
begin
  ShowMessage('Ich heiße jetzt ' + NewName);
end;

procedure TFormTest.btnNewDogClick(Sender: TObject);
var
  Hund: THund;
begin
  Hund := THund.Create;
  try
    Hund.OnRename := Hund.ShowNewName;
    ShowMessage(Hund.Name); //Bello
    Hund.Name := 'Hasso';
  finally
    Hund.Free;
  end;
end;

[/edit]

[NetSonic]

Danke DeddyH - Dein Beispiel hat in meinem Kopf wieder für Klarheit gesorgt. Wie man gesehen hat, habe ich ja selbst die Deklaration meiner Methode verdrängt... ;-)

Ich habe mich jetzt an Deinem Beispiel orientiert und entsprechend meiner Anforderungen angepasst. Zusätzlich habe ich die "ShowNewName" als Virtual deklariert, um bei jedem abgeleiteten Formular mit override entsprechend individuelle Varianten nutzen zu können.

Vielen Dank nochmal für die Geduld und die tolle Hilfestellung. :thumb:
Manchmal hat man dann doch ein Kantholz vor dem Kopf...

NetSonic

[DeddyH]

Schön, dass es jetzt "Klick" gemacht hat. Aber um das noch einmal klarzustellen: Events machen nur dann Sinn, wenn sie eine Schnittstelle zur "Außenwelt" darstellen. Geht es nur um Vererbung, dann reichen ja auch virtuelle Methoden (ggf. sogar abstrakte in der Basisklasse).