Moin,

ich trete im Monet auf der Stelle,
Ich habe ein Hauptformular auf dem ein "TPageControl" platziert ist.
Der Inhalt jedes "TTabSheet" kommt aus einer eignen Unit und wird mittel

zusammenfalten · markieren

Delphi-Quellcode:

procedure TMainForm.FormCreate(Sender: TObject);

begin
// Die Einzelnen Units an die TABs binden
 Form_Allgemein:= TForm_Allgemein.Create(Self);
 Form_Allgemein.Parent:=Tab01_Allgemein;
 Form_Allgemein.Show;
 //
 Form_BMK:= TForm_BMK.Create(Self);
 Form_BMK.Parent:=Tab02_Betriebsmittel;
 Form_BMK.Show;
 Form_BMK.rg_Geraetetyp.ItemIndex:=0;
 Form_BMK.rg_BmKAufbau.ItemIndex:=0;
 Form_BMK.lbledt_BmkAufbau.Text:='1,2,3,4';
  //
 Form_TechDaten:= TForm_TechDaten.Create(Self);
 Form_TechDaten.Parent:=Tab03_Tech_Daten;
 Form_TechDaten.Show;
  //
 Form_Material:= TForm_Material.Create(Self);
 Form_Material.Parent:=Tab04_Material;
 Form_Material.Show;
 Form_Material.chklst_Artikeldaten.Enabled:=False;
  //
 Form_Anschluesse:= TForm_Anschluesse.Create(Self);
 Form_Anschluesse.Parent:=Tab05_Anschluesse;
 Form_Anschluesse.Show;
end;

eingebunden.
Wenn eine "TComboBox" auf "Allgemein" verändert wird, sollen auf "Anschlüsse" Objekte entweder auf "Enable = True" bwz "Enable = False" gesetzt werden.

Da ich nicht jede Unit in jeder Unit usen will, soll das de-/aktivieren also in der Unit "Anschlüsse" oder im Hauptformular durchgeführt werden.

Aber, ich finde kein Ereignis, in dem ich das de-/aktivieren platzieren kann und es auch ausgeführt wird?

Es müsste ja ein Ereignis sein, das immer aktiviert wird wenn sich irgenwo was ändert oder in bestimmten sehr kurzen Zeitabschnitten ausgeführt wird.

Ich habe im Moment keinen Plan wie ich das anstellen soll.

Könnt Ihr helfen?

Gruß HEiko

Zitat von Kralle:

ich trete im Monet auf der Stelle

Gut dass der schon tot ist

Du könntest Deine Formulare von einer Klasse erben und dort ein Notifiy Event einführen, das von allen OnChange der Comboboxen und anderer Controls aufgerufen wird. Diesen Event belegst Du dann beim Laden des jeweiligen Formulars in das Tabsheet.

Ohne wirklich zu wissen, wovon ich rede (mein XE ist da nicht aktuell genug): könnte man nicht aus den Formularen Frames machen, die dann zur Designtime auf den TabSheets verteilen und alles per LiveBindings miteinander verknüppeln? Ist aber nur so ein Gedanke, ausprobieren kann ich es ja nicht.

Warum nimmst du keine Frames?

Dann könntest du auch im Hauptformular ein OnChange für ein Control des "Allgemein"-Frame platzieren und drin wiederum auf Controls im "Anschlüsse".Frame zugreifen.

Eine Möglichkeit ist das Observer Pattern.

Eine andere Möglichkeit wäre einen Messenger zu implementieren, wo sich jede Instanz einklinken kann um bestimmte Nachrichten mitzuhören und zu reagieren, wenn da was Interessantes dabei ist.

http://www.galasoft.ch/mvvm/ (Messenger ist kein Delphi, aber die Idee ist gut)

Generell würde ich dir auch empfehlen, eine zentrale Methode jeweils zum Laden und Speichern der Control-Inhalte zu schaffen.

Meine BasisForm sieht z.B. so aus:

zusammenfalten · markieren

Delphi-Quellcode:

TFormView = class( TForm )
  procedure ControlChange( Sender : TObject );
private
  FModelLoading : Boolean;
protected
  procedure DoLoadFromModel; virtual; abstract;
  procedure DoSaveToModel; virtual; abstract;

  procedure LoadFromModel;
  procedure SaveToModel;
  procedure SyncWithModel;
end;

procedure TFormView.LoadFromModel;
begin
  if FModelLoading then Exit;

  FModelLoading := True;
  try
    DoLoadFromModel;
  finally
    FModelLoading := False;
  end;
end;

procedure TFormView.SaveToModel;
begin
  if FModelLoading then Exit;
  DoSaveToModel;
end;

procedure TFormView.SyncWithModel;
begin
  SaveToModel;
  LoadFromModel;
end;

procedure TFormView.ControlChange( Sender : TObject );
begin
  SyncWithModel;
end;

An jedes Control (Edit, ComboBox, etc.) hänge ich einfach die Methode ControlChange dran und kann mir sicher sein, dass die Daten ausgetauscht werden.
Wie der Austausch konkret aussieht, das wird in DoLoadFromModel und DoSaveToModel in den abgeleiteten Forms implementiert.

Wenn du dann eine Nachricht bekommst, dass sich an den Daten etwas geändert hat, dann brauchst du auch nur ganz stumpf in der Form LoadFromModel aufrufen und du bist fein raus.

Hallo Sir Rufo,

Zitat von Sir Rufo:

Eine Möglichkeit ist das Observer Pattern.

Also, ich habe mir das hier mal angeschaut:
https://www.danielwolf.eu/blog/2013/...mit-delphi-xe4
und bekomme einen Knoten im Kopf.

Zitat von Sir Rufo:

http://www.galasoft.ch/mvvm/ (Messenger ist kein Delphi, aber die Idee ist gut)

Bin ja offensichtlich schon mit Delphi und seinen Eigenheiten überfordert und finde immer wieder Situationen vor, die ausser mir keiner hat.

Zitat von Sir Rufo:

Generell würde ich dir auch empfehlen, eine zentrale Methode jeweils zum Laden und Speichern der Control-Inhalte zu schaffen.

Wäre wahrscheinlich genauso sinnvoll wie die zentralle Ablage von Variablen.

Zitat von Sir Rufo:

Meine BasisForm sieht z.B. so aus:

Nimmst Du dafür auch wieder eine eigene Unit oder würdest Du das in in eine andere Unit mit reinpacken.
Ansonsten sieht das erstmal nihct zu kompliziert aus.
Und das muß ich jetzt für jedes Objekt machen?
Also, für Form1, Form2 , usw?

Zitat:

An jedes Control (Edit, ComboBox, etc.) hänge ich einfach die Methode ControlChange dran und kann mir sicher sein, dass die Daten ausgetauscht werden.
Wie der Austausch konkret aussieht, das wird in DoLoadFromModel und DoSaveToModel in den abgeleiteten Forms implementiert.

Wie macht man so was?

Zitat:

Wenn du dann eine Nachricht bekommst, dass sich an den Daten etwas geändert hat, dann brauchst du auch nur ganz stumpf in der Form LoadFromModel aufrufen und du bist fein raus.

??? Bahnhof ???

Gruß Heiko

Moin,

Zitat von bcvs:

Warum nimmst du keine Frames?

Hatte ich mal in einem anderen Projekt und fand das sehr unpraktisch.
(Okay, vielleicht hatte ich auch falsche Vorstellungen)

Zitat:

Dann könntest du auch im Hauptformular ein OnChange für ein Control des "Allgemein"-Frame platzieren und drin wiederum auf Controls im "Anschlüsse".Frame zugreifen.

Aber, dann habe ich doch wieder die Situation, das das alles untereinander verwurschelt ist und man irgendwann icht mehr weiß von woaus überall auf die Eigenschaften eines Objektes zugegriffen wird.

Was mich wundert ist die Tatsache, das es immer heißt man sollte den Code nicht in eine Unit packen sondern eine Unit pro Funktion.
Das wird bestimmt schon seit BP7 oder früher propagiert, aber einen einfachen, direkten, logischen Weg Informationen zwischen den Units auszutauschen scheint es nicht zugeben.

Gruß HEiko

Die Formulare werden vererbt, das ist die Basis-Form, von der ich dann meine weiteren Forms ableite.
Darum brauche ich das in den konkreten Forms eben nicht noch mal schreiben sondern nur noch benutzen

Alle Controls sollen bei einer Änderung SyncWithModel aufrufen.
Die meisten Controls haben eine Eigenschaft OnChange : TNotifyEvent .
Darum habe ich die Methode ControlChange( Sender : TObject ) , die bei den meisten Controls schon passt geschrieben (wegen Bequemlichkeit und DRY )

markieren

Delphi-Quellcode:

Firstname_Edit.OnChange := ControlChange;
Lastname_Edit.OnChange := ControlChange;
Country_ComboBox.OnChange := ControlChange;
Whatever_ListBox.OnClick := ControlChange;

Wenn ein Control damit nicht abzutüten ist, dann suche ich mir das passende Event heraus und schreibe in die EventMethode

markieren

Delphi-Quellcode:

procedure TMyFormView.SomeControlEvent( Sender : TObject; AParam : string );
begin
  ControlChange( Sender ); // geht also doch ;o)
end;

LoadFromModel sorgt dafür, dass die Controls mit den richtigen Daten gefüllt werden (wenn du in der konkreten Form die Methode DoLoadFromModel passend implementiert hast).

Bekommst du jetzt von wo auch immer her die Information, dass sich die Daten geändert haben, dann ruf einfach LoadFromModel auf und die Control werden mit den Werten gefüllt.

Zitat von Kralle:

Was mich wundert ist die Tatsache, das es immer heißt man sollte den Code nicht in eine Unit packen sondern eine Unit pro Funktion.

Ähm nicht ganz, eine Unit pro Funktionalität.

Im Anhang ist eine kleine Demo-Anwendnung

Alle Elemente sind sehr lose gekoppelt und tauschen sich nur über Nachrichten aus.
Die ausgetauschten Nachrichten lasse ich hier auf der rechten Seite anzeigen.

Da die grundlegenden Units zum Messenger/ViewModel/Model etc. zwar schon sehr weit fortgeschritten aber noch nicht komplett fertig sind, gibt es im Moment nur den Code der konkreten Ableitungen.

zusammenfalten · markieren

Delphi-Quellcode:

unit Model.DemoData;

interface

uses
  MVVM.Model;

type
  TDemoDataModel = class( TModel )
  private
    FStr : string;
    FInt : Integer;
    procedure SetStr( const Value : string );
    procedure SetInt( const Value : Integer );
  public
    property Str : string read FStr write SetStr;
    property Int : Integer read FInt write SetInt;
  end;

implementation

{ TDemoDataModel }

procedure TDemoDataModel.SetInt( const Value : Integer );
begin
  // SetField<T>( var Field : T; const Value : T; const PropName : string )
  // Setzt den Wert der Variablen und schickt eine Nachricht, wenn sich der Wert geändert hat

  SetField<Integer>( FInt, Value, 'Int' );
end;

procedure TDemoDataModel.SetStr( const Value : string );
begin
  SetField<string>( FStr, Value, 'Str' );
end;

end.

zusammenfalten · markieren

Delphi-Quellcode:

unit ViewModel.Main;

interface

uses
  MVVM.ViewModel, MVVM.Messenger.Messages, Model.DemoData;

type
  TMainViewModel = class( TViewModel )
  private
    FCurrentPageIndex : Integer;
    FData : TDemoDataModel;
    procedure SetCurrentPageIndex( const Value : Integer );
  protected
    procedure MsgPropertyChanged( const AMessage : TPropertyChangedMessage ); override;
  public
    procedure AfterConstruction; override;
    procedure BeforeDestruction; override;
    property CurrentPageIndex : Integer read FCurrentPageIndex write SetCurrentPageIndex;
    property Data : TDemoDataModel read FData;
  end;

implementation

{ TMainViewModel }

procedure TMainViewModel.AfterConstruction;
begin
  inherited;
  FData := TDemoDataModel.Create;
end;

procedure TMainViewModel.BeforeDestruction;
begin
  inherited;
  FData.Free;
end;

procedure TMainViewModel.MsgPropertyChanged( const AMessage : TPropertyChangedMessage );
begin
  inherited;
  if AMessage.Sender = FData then
    DoNotify( 'Data.' + AMessage.PropName );
end;

procedure TMainViewModel.SetCurrentPageIndex( const Value : Integer );
begin
  SetField<Integer>( FCurrentPageIndex, Value, 'CurrentPageIndex' );
end;

end.

zusammenfalten · markieren

Delphi-Quellcode:

unit ViewForm.Main;

interface

uses
  MVVM.Messenger.Messages, MVVM.ViewModel,
  ViewModel.Main,
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, ViewForm, Vcl.ComCtrls, Vcl.StdCtrls,
  Vcl.ExtCtrls;

type
  TMainFormView = class( TFormView )
    PageControl1 : TPageControl;
    ListBox1 : TListBox;
    Panel1 : TPanel;
    AddView_Button : TButton;
    GroupBox1 : TGroupBox;
    Panel2 : TPanel;
    GroupBox2 : TGroupBox;
    Edit1 : TEdit;
    ComboBox1 : TComboBox;
    procedure AddView_ButtonClick( Sender : TObject );
  private
    FViewModel : TMainViewModel;
    procedure AddPageView;
  protected
    procedure MsgPropertyChanged( const AMessage : TPropertyChangedMessage ); override;
    procedure DoLoadFromModel; override;
    procedure DoSaveToModel; override;
    procedure DoGetViewModel( var ViewModel : TViewModel ); override;
  public
    procedure AfterConstruction; override;
    procedure BeforeDestruction; override;
  end;

var
  MainFormView : TMainFormView;

implementation

{$R *.dfm}
{ TMainFormView }

procedure TMainFormView.AddPageView;
var
  LViewClass : TPersistentClass;
  LView : TFormView;
begin
  // Die konkrete Klasse TDataEditFormView ist nicht bekannt (keine Abhängigkeiten=lose Koppelung)
  // darum wird die über einen Alias gesucht
  LViewClass := FindClass( 'DataEditView' );

  if LViewClass.InheritsFrom( TFormView ) then
  begin

    LView := TFormClass( LViewClass ).Create( Self ) as TFormView;

    // Verdrahtung der ViewModels
    LView.ViewModel.Parent := FViewModel;

    // ab ins PageControl
    LView.ManualDock( PageControl1 );
    LView.Align := alClient;
   
    // und anzeigen
    LView.Show;
  end;
end;

procedure TMainFormView.AddView_ButtonClick( Sender : TObject );
begin
  inherited;
  AddPageView;
end;

procedure TMainFormView.AfterConstruction;
var
  LView : TFormView;
begin
  inherited;
  FViewModel := TMainViewModel.Create;

  // Eine View packen wir schon mal hinzu
  AddPageView;

  // Setze ich normalerweise im OI (Bequemlichkeit)
  PageControl1.OnChange := ControlChange;
  Edit1.OnChange := ControlChange;
  ComboBox1.OnChange := ControlChange;
end;

procedure TMainFormView.BeforeDestruction;
begin
  inherited;
  FreeAndNil( FViewModel );
end;

procedure TMainFormView.DoGetViewModel( var ViewModel : TViewModel );
begin
  inherited;
  ViewModel := FViewModel;
end;

procedure TMainFormView.DoLoadFromModel;
begin
  inherited;
  PageControl1.ActivePageIndex := FViewModel.CurrentPageIndex;
  Edit1.Text := FViewModel.Data.Str;
  ComboBox1.ItemIndex := FViewModel.Data.Int;
end;

procedure TMainFormView.DoSaveToModel;
begin
  inherited;
  FViewModel.CurrentPageIndex := PageControl1.ActivePageIndex;
  FViewModel.Data.Str := Edit1.Text;
  FViewModel.Data.Int := ComboBox1.ItemIndex;
end;

procedure TMainFormView.MsgPropertyChanged( const AMessage : TPropertyChangedMessage );
begin
  inherited;
  ListBox1.ItemIndex := ListBox1.Items.Add( Format( '%s(%x).%s', [AMessage.Sender.ClassName, Integer( AMessage.Sender ), AMessage.PropName] ) );
end;

end.

zusammenfalten · markieren

Delphi-Quellcode:

unit ViewModel.DataEdit;

interface

uses
  MVVM.ViewModel, MVVM.Messenger.Messages;

type
  TDataEditViewModel = class( TViewModel )
  private
    function GetStr : string;
    procedure SetStr( const Value : string );
    function GetInt : Integer;
    procedure SetInt( const Value : Integer );
  protected
    procedure MsgPropertyChanged( const AMessage : TPropertyChangedMessage ); override;
  public
    property Str : string read GetStr write SetStr;
    property Int : Integer read GetInt write SetInt;
  end;

implementation

uses
  System.StrUtils,
  ViewModel.Main;

{ TDataEditViewModel }

function TDataEditViewModel.GetInt : Integer;
begin
  if Parent is TMainViewModel then
    Result := ( Parent as TMainViewModel ).Data.Int
  else
    Result := -1;
end;

function TDataEditViewModel.GetStr : string;
begin
  if Parent is TMainViewModel then
    Result := ( Parent as TMainViewModel ).Data.Str
  else
    Result := '';
end;

procedure TDataEditViewModel.MsgPropertyChanged( const AMessage : TPropertyChangedMessage );
begin
  inherited;
  if AMessage.Sender = Parent then
    case IndexText( AMessage.PropName, ['Data.Str', 'Data.Int'] ) of
      0 :
        DoNotify( 'Str' );
      1 :
        DoNotify( 'Int' );
    end;
end;

procedure TDataEditViewModel.SetInt( const Value : Integer );
begin
  if Parent is TMainViewModel then
    ( Parent as TMainViewModel ).Data.Int := Value;
end;

procedure TDataEditViewModel.SetStr( const Value : string );
begin
  if Parent is TMainViewModel then
    ( Parent as TMainViewModel ).Data.Str := Value;
end;

end.

zusammenfalten · markieren

Delphi-Quellcode:

unit ViewForm.DataEdit;

interface

uses
  MVVM.ViewModel, MVVM.Messenger.Messages,
  ViewModel.DataEdit,
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, ViewForm, Vcl.StdCtrls;

type
  TDataEditFormView = class( TFormView )
    ListBox1 : TListBox;
    Edit1 : TEdit;
  private
    FViewModel : TDataEditViewModel;
  protected
    procedure DoLoadFromModel; override;
    procedure DoSaveToModel; override;
    procedure DoGetViewModel( var ViewModel : TViewModel ); override;
  public
    procedure AfterConstruction; override;
    procedure BeforeDestruction; override;
  end;

var
  DataEditFormView : TDataEditFormView;

implementation

{$R *.dfm}
{ TDataEditFormView }

procedure TDataEditFormView.AfterConstruction;
begin
  inherited;
  FViewModel := TDataEditViewModel.Create;

  ListBox1.OnClick := ControlChange;
  Edit1.OnChange := ControlChange;
end;

procedure TDataEditFormView.BeforeDestruction;
begin
  inherited;
  FViewModel.Free;
end;

procedure TDataEditFormView.DoGetViewModel( var ViewModel : TViewModel );
begin
  inherited;
  ViewModel := FViewModel;
end;

procedure TDataEditFormView.DoLoadFromModel;
begin
  inherited;
  ListBox1.ItemIndex := FViewModel.Int;
  Edit1.Text := FViewModel.Str;
end;

procedure TDataEditFormView.DoSaveToModel;
begin
  inherited;
  FViewModel.Int := ListBox1.ItemIndex;
  FViewModel.Str := Edit1.Text;
end;

initialization

RegisterClassAlias( TDataEditFormView, 'DataEditView' );

end.

Nachtrag

Zum Verständnis: In TFormView ist definiert, dass bei einer Änderung des zugehörigen ViewModels automatisch LoadFromModel aufgerufen wird.
(hier konkret in einer LazyLoadFromModel, wo erst 100ms nach der letzen Änderung das Laden erfolgt - das kann man sehr schön sehen, wenn man im Edit-Feld eine Taste gedrückt lässt)

Moin,

Zitat von bcvs:

Warum nimmst du keine Frames?

Dann könntest du auch im Hauptformular ein OnChange für ein Control des "Allgemein"-Frame platzieren und drin wiederum auf Controls im "Anschlüsse".Frame zugreifen.

Also, ich habe jetzt ein Musterprojekt erstellt.
Enthalten ein Formular und zwei Frames. Angezeigt bekomme ich die Frames, aber ich kann vom Formular auf keine Ereignise oder Eigenschaften der Frames und deren Objekte zugreifen.

Irgendwie schein ich zu doof zu sein.

Gruß Heiko

Nachtrag: Ich habe es hinbekommen.
Mein Fehler war, das ich die Frames per Code so eingebunden habe wie vorher die einzelnen Units.
Nach dem ich aber auf jedem TabSheet die Komponente "Frames" platziert habe und das entsprechende Frame ausgewählt habe,
landen Ereignisse die ich in dem TabSheet-Frame auswähle auch in der Hauptprocedure und ich kann einfach auf alle Komponenten zugreifen.

Jetzt muß ich mal schauen, ob ich aus meinen einzelnen Units Frames machen kann ohne das ich alle visuellen Komponenten neu erstellen muß.