wo Initialisierungen von Formularen durchführen.

[diver03]

Hallo,

ich bin zwar kein Neuling, was Programmieren angeht, aber Object Programmierung ist schon neu für mich.
Habe vor vielen Jahren viel in Fortran, Pascal und C programmiert, als es noch keine Objekte gab.

Weiß auch nicht, ob das Thema hier richtig ist. Wenn nicht, bitte verschieben.

Nun zu meiner Frage. (der Titel kling vielleicht etwas komisch)

Ich habe ein Berechnungprogramm geschrieben, was zur Zeit nur aus einem Formular besteht, das aber voll ist mit
Labels und Edit Boxen, deshalb möchte ich bei Bedarf ein zweites Formular öffnen für weiter Daten.
Ich habe das Programm so aufgebaut, dass ich zwische Deutsch und Englisch umschalten kann.
Dazu wird in einer Procedur eine entsprechende Sprachdatei eingelesen und entsprechend die
Label.Caption geändert.

Zu Programmstart wird nun in der "Create" Procedur des Hauptformulars die Sprach Procedur aufgerufen.

Da das zweite Formular nach dem ersten erzeugt wird, bekomme ich verständlicher Weise eine Fehlermeldung,
wenn einem Label vom zweiten Formular ein Text zugewiesen wird, bevor das 2. Formular erzeugt wird.

Die Frage ist nun, wo kann man eine Procedur einbinden, nachdem alle Formulare erzeugt wurden, bevor das
Programm dann auf eine Ereignis wartet?
Kann man einen Aufruf im Programm vor der Zeile Application.Run einfügen, oder ist das kein guter Delphi Stil?

Alles verstanden?

MfG
Jens Peter

[mkinzler]

Kannst du machen. Du könntest aber im 1. Formular (Sprachwahl) die weiteren Formulare erzeugen.

[toms]

Hallo

Das OnShow Ereignis der Hauptform wird ausgeführt, sobald alle Formulare erzeugt wurden.

[diver03]

Hallo

danke für eure Antworten.

@mkinzler: ich habe ins Hauptprogramm vor Application.Run jetzt einen Proceduraufruf "FormShow"
eingefügt (nach der Erzeugung aller Formulare und damit scheint es zu funktioniern.
Scheint deshalb, weil ich es eben nur schnell mit einem Label getestet habe.

@toms: mit onShow geht es nicht, bzw. habe ich es nicht geschafft.
onShow wird schon vor dem Create des zweiten Formulars ausgeführt.

Delphi-Quellcode:

begin
  Application.Initialize;
  Application.Title := 'Test R 3.1.0';
  Application.CreateForm(TForm_Hauptformular, Form_Hauptformular);
  Application.CreateForm(TDruck_einrichten, Druck_einrichten);
  Application.CreateForm(TForm_MDaten, Form_MDaten);
  Form_Hauptformular.FormShow(Form_Hauptformular);
  Application.Run;
end.

[toms]

Zitat:

Zitat von diver03

@toms: mit onShow geht es nicht, bzw. habe ich es nicht geschafft.
onShow wird schon vor dem Create des zweiten Formulars ausgeführt.

Kann ich nicht nachvollziehen und wäre mir neu.
Die Hauptform wird er durch Application.Run sichtbar gemacht, außer die Form wird zuvor "manuell" sichtbar gemact.

[diver03]

vielleicht habe ich auch nur nicht so ganz verstanden, wie ich das anwenden muss.

Ich habe im Hauptformular im Objectinspector bei onShow meine eigene Procedur "FormShow"
eingetragen, die, die ich jetzt vor den ...Run Befehl gesetzt habe.
Ist das so richtig?

Nun noch eine andere Frage.
Wien kann ich erreichen, dass die Texte von zwei Editfeldern aus zwei verschiedenen
Formularen immer den gleichen Inhalt haben, auch dann, wenn ich eines der Felder änder?
Ich muss noch dazu sagen, dass das eine Feld inactiv und read only ist.

[diver03]

mir die Frage schon selber beantwortet.
Habe onChange benutzt.

[toms]

Zitat:

Zitat von diver03

mir die Frage schon selber beantwortet.
Habe onChange benutzt.

Zur Info -> Es gilt hier die Regel: Neue Frage zu einem anderen Thema -> Neues Thema eröffnen.

Delphi-Quellcode:

Form_Hauptformular.FormShow(Form_Hauptformular);

Ist unnötig, da die Hauptform durch Run angezeigt wird.

[diver03]

Zitat:

Form_Hauptformular.FormShow(Form_Hauptformular);

das hat nicht wirklich was mit "Show" zu tun, mir ist nur kein anderer Name
auf die Schnelle eingefallen.
Ich werde die procedur noch umbennen in "SprachenLaden"

Danke erstmal für die hilfreichen Tipps.

Gruß
Jens

[dataspider]

Hi,

ich nutze für ähnliche Probleme Application.OnIdle.
Im MainForm Constructor weise ich Application.OnIdle eine Methode zu.

Delphi-Quellcode:

constructor TfrmMain.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  Application.OnIdle := ApplicationOnIdle;
  ...
end;

procedure TfrmMain.ApplicationOnIdle(Sender: TObject; var Done: Boolean);
begin
  Application.OnIdle := nil;
  SetLanguage; // z.B.
end;

Wobei die Procedure nicht in das Hauptformular gehört, aber na ja...

Cu, Frank

[alzaimar]

Ich würde mir eine generische Formular-Klasse erstellen, die die Label-Beschriftungen bei Bedarf aus einer Datei lädt.
Weiterhin würde ich mir einen Observer (GOF-Strategy, Observer-Pattern) schreiben, der beim Sprachenwechsel alle Formulare benachrichtigt.

Die Formulare melden sich beim Observer an (subscribe), sobald sie erzeugt werden (FormCreate-Methode) und melden sich wieder ab (unsubscribe), wenn sie zerstört werden (FormDestroy).

Alle deine Formulare leitest Du dann von diesem TMultiLanguageForm ab und musst dich dann um gar nichts mehr kümmern.

Der Observer verwaltet eigentlich nur eine Liste von TMultiLanguageForm. Meldet sich eine Form an, kommt es in die Liste. meldet sie sich ab, wird sie aus der Liste entfernt. Beim Sprachwechsel werden einfach alle Formulare der Liste nacheinander aufgefortert, ihre Spracheinstellungen neu zu laden.

Delphi-Quellcode:

unit MultiLingualForms;

interface
uses Classes, Forms;
Type

  IObserverReceiver = Interface
     Procedure Notify (Const aMessage : String);
     End;

  TLanguageObserver = Class
  private
    FObserver : TInterfaceList;
  Public
    Constructor Create;
    Destructor Destroy; Override;
    Procedure Subscribe (aObserver : IObserverReceiver);
    Procedure Unsubscribe(aObserver : IObserverReceiver);
    Procedure Notify;
    End;

  TMultiLanguageForm = Class (TForm, IObserverReceiver)
  protected
    Procedure DoCreate; Override;
    Procedure DoDestroy; Override;
    Procedure ChangeLanguage;
    Procedure IObserverReceiver.Notify = ChangeLanguage;
  End;

Function Observer : TLanguageObserver;

implementation

{ TLanguageObserver }
Var
  _Observer : TLanguageObserver;

Function Observer : TLanguageObserver;
Begin
  If not Assigned (_Observer) Then _Observer := TLanguageObserver.Create;
  Result := _Observer
End;

constructor TLanguageObserver.Create;
begin
  inherited;
  FObserver := TInterfaceList.Create;
end;

destructor TLanguageObserver.Destroy;
begin
  FObserver.Free;
  inherited;
end;

procedure TLanguageObserver.Notify;
Var
  i : Integer;

begin
  For i:=0 To FObserver.Count-1 do
    IObserverReceiver(FObserver[i]).Notify;
end;

procedure TLanguageObserver.Subscribe(aObserver: IObserverReceiver);
begin
  If FObserver.IndexOf(aObserver)=-1 Then
    FObserver.Add(aObserver)
end;

procedure TLanguageObserver.Unsubscribe(aObserver: IObserverReceiver);
begin
  FObserver.Remove(aObserver)
end;

{ TMultiLanguageForm }

procedure TMultiLanguageForm.DoCreate;
begin
  inherited;
  Observer.Subscribe(Self);
  ChangeLanguage;
end;

procedure TMultiLanguageForm.DoDestroy;
begin
  Observer.Unsubscribe(Self);
  inherited;
end;

procedure TMultiLanguageForm.ChangeLanguage;
begin
// Sprachdatei laden und eigene Label neu setzen
end;

initialization
  _Observer := Nil;
finalization
  _Observer.Free;
end.

Beim Sprachwechsel einfach 'Observer.Notify' aufrufen, der macht den Rest.


Nebenbei gibt es sehr schöne Tools, die einem die Entwicklung mehrsprachiger Anwendungen erleichtern. GnuGetText oder TsiLang sind zwei Kandidaten, aber es gibt sicherlich noch Andere.