Konzeptfrage FormCreate

[WIng2005]

Klar... die Funktion von uligerhardt weiter oben funktioniert nicht. Ich habe es mit dem Cast von Zoot umgesetzt.

[Chemiker]

Hallo WIng2005,

also normalerweise braucht man für die Übergabe eines Objektes kein var-Parameter, weil es sich schon um einen Zeiger handelt.

Hast Du das neu Erstelltes Formular unter Projektoptionen von Automatisch erzeugtes auf Verfügbares Form gestellt?

Des weiteren würde ich die Procedure:

Delphi-Quellcode:

 function formerzeugen(fclass:TFormClass;var nform):boolean;

unter public schreiben damit man kein Problem mit der Sichtbarkeit bekommt.

Bis bald Chemiker

[uligerhardt]

Zitat:

Zitat von Chemiker

also normalerweise braucht man für die Übergabe eines Objektes kein var-Parameter, weil es sich schon um einen Zeiger handelt.

Ja, aber hier muss ja der Zeiger umgebogen werden. Z.B. soll nach dem Aufruf

Delphi-Quellcode:

formerzeugen(TForm2,TForm(form2));

Form2 auf die neu erstellte Instanz verweisen.

[WIng2005]

Hallo,

die Frage der Sichtbarkeit wie auch die Einstellungen in den Projektoptionen hatte ich berücksichtigt.
Ich werde mir die Referenz/Wertparameterübergabe heute abend nocheinmal anschauen. Erstmal habe ich (zumindest für mein Projekt) eine funktionierende Lösung. Der Lerneffekt muss leider bis nach der Arbeit warten... :?

[Chemiker]

Hallo WIng2005,

ich bin mir immer noch unsicher, ob ich Deine Frage richtig verstanden habe. Ich arbeite bevorzugt mit einer Lösung wo das Fenster selber für die Erstellung und Zerstörung zuständig ist.

Mal ein Beispiel:

Zuerst die Class-Unit für die Daten ist nicht besonderes nur zum Spielen.

Delphi-Quellcode:

unit uPersonenKlasse;

interface

uses 
  Classes;  

type
  THPLPersonen= Class (TObject)
  private
    FVorName: String;
    FNachName: String;
    procedure GetFNachName(const Value: String);
    procedure GetFVorName(const Value: String);
    function SetFNachName: String;
    function SetFVorName: String;
  public
    property VorName: String read SetFVorName write GetFVorName;
    property NachName: String read SetFNachName write GetFNachName;  
  End;

  implementation

{ THPLPersonen }

procedure THPLPersonen.GetFNachName(const Value: String);
begin
  if Value <> FNachName then
  begin
    FNachName:= Value
  end;
end;

procedure THPLPersonen.GetFVorName(const Value: String);
begin
  if Value <> FVorName then
  begin
    FVorName:= Value
  end;
end;

function THPLPersonen.SetFNachName: String;
begin
  result:= FNachName;
end;

function THPLPersonen.SetFVorName: String;
begin
   result:= FVorName;
end;  

end.

So nun das Hauptformular:

Delphi-Quellcode:

unit frmHauptFenster;

interface

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

type
  TfrmMainForm = class(TForm)
    edVorName: TEdit;
    edNachName: TEdit;
    btFormOeffnen: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure btFormOeffnenClick(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
    FPersonen: THPLPersonen;
  end;

var
  frmMainForm: TfrmMainForm;

implementation

{$R *.dfm} 

procedure TfrmMainForm.btFormOeffnenClick(Sender: TObject);
begin
  FPersonen.VorName:= edVorName.Text;
  FPersonen.NachName:= edNachName.Text;
  TfrmAufgerufen.FormAufrufen(FPersonen);   // Dynamische –Formular aufrufen
  edVorName.Text:= FPersonen.VorName;
  edNachName.Text:= FPersonen.NachName;
end;

procedure TfrmMainForm.FormCreate(Sender: TObject);
begin
  FPersonen:= THPLPersonen.Create;
end;

procedure TfrmMainForm.FormDestroy(Sender: TObject);
begin
  FPersonen.Free;   
end;

end.

Ist eigentlich nichts Besonderes, bis auf die Zeile wo das Dynamische -Formular aufgerufen wird.

Nun kommt, dass dynamische Form:

Delphi-Quellcode:

unit uDynamischesFenster;

interface

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

type
  TfrmAufgerufen = class(TForm)
    edVorName: TEdit;
    edNachName: TEdit;
    btAbbruch: TButton;
    btOK: TButton;
    procedure btOKClick(Sender: TObject);
  private
    FPersonenKopie: THPLPersonen;
    procedure EditFelderFuellen;
  public
    class procedure FormAufrufen (aPersonen: THPLPersonen);
  end;

var
  frmAufgerufen: TfrmAufgerufen;

implementation

{$R *.dfm}

{ TfrmAufgerufen }  

class procedure TfrmAufgerufen.FormAufrufen(aPersonen: THPLPersonen);
begin
  with TfrmAufgerufen.Create(NIL) do
  try
    FPersonenKopie:= aPersonen;
    EditFelderFuellen;
    if ShowModal= mrOk then
    begin
      aPersonen:= FPersonenKopie;
    end;
  finally
    free;    
  end; 
end;

procedure TfrmAufgerufen.EditFelderFuellen;
begin
  edVorName.Text:= FPersonenKopie.VorName;
  edNachName.Text:= FPersonenKopie.NachName; 
end;

procedure TfrmAufgerufen.btOKClick(Sender: TObject);
begin
  FPersonenKopie.VorName:= edVorName.Text;
  FPersonenKopie.NachName:=edNachName.Text; 
end;

end.

Zu beachten ist das die Eigenschaft ModalResult vom OK-Button auf mrOK gestellt wird.

Die Bezeichnungen sollten hoffentlich selbsterklärend sein.

Bis bald Chemiker

[WIng2005]

Hallo Chemiker,

vielen Dank für dein Beispiel... wird heute meine "Zuglektüre" :)
Mein Vorhaben ist, mehrere Forms (Anzahl wächst stetig) dynamisch auf einem Panel der Hauptform einzubetten.
Es sollen quasi je nach Auswahl in einem Menu die zugehörigen Module angezeigt werden. Um nun nicht jedesmal den gleichen Code beim Aufruf des Moduls aufzuführen, suchte ich nach einer Funktion, welcher ich die entsprechenden Parameter übergeben kann um so
bei der Fallunterscheidung nur noch je 1 Zeile Code zu haben.

[Stevie]

Zitat:

Zitat von WIng2005

Mein Vorhaben ist, mehrere Forms (Anzahl wächst stetig) dynamisch auf einem Panel der Hauptform einzubetten.
Es sollen quasi je nach Auswahl in einem Menu die zugehörigen Module angezeigt werden. Um nun nicht jedesmal den gleichen Code beim Aufruf des Moduls aufzuführen, suchte ich nach einer Funktion, welcher ich die entsprechenden Parameter übergeben kann um so
bei der Fallunterscheidung nur noch je 1 Zeile Code zu haben.

Bei so etwas würde ich persönlich eher auf Frames zurückgreifen.
Erstellung irgendwo in deinem Mainform wie folgt - hab ma der Einfachheit halber auf sämtliches Exceptionhandling verzichtet und alles in eine Zeile gehauen :)

Delphi-Quellcode:

TMyFrame.Create(Self).Parent := MyPanel;

[WIng2005]

Welchen Vorteil hat denn die Verwendung von Frames gegenüber Forms im konkreten Fall?

[Stevie]

Forms sind normalerweise als eigenes Window gedacht, und eher sekundär, um sie in ein anderes Control einzubetten, dafür gibt es Frames. Nachteil von Frames ist hingegen, dass sie einige Events nicht haben, wie OnShow etc.
Bei dir handelt es sich - wie ich verstanden habe - um eine Art Control-Sammlung die du abhängig von der Aktion in deinem Programm einzeigst und die nicht als eigenständiges Window existiert, daher würde ich zu einem Frame raten. Solltest du diese Frames dennoch als eigenständiges Fenster einzeigen wollen, könntest du ein Standard-Dialog Fenster erstellen (mit Ok und Cancel Button und was du noch brauchst) und dort dann den Frame als Content einbetten.

Weitere Infos:
TForm vs TFrame - How to decide which one to use?

[WIng2005]

Vielen Dank für den Link..
Die fehlenden Events (besonders Create und Destroy) könnten mir zum Verhängnis werden... Aber konnte das Ganze bisher nur überfliegen.... lese es mir gleich nochmal genauer durch...