Formular Position speichern, Generell wenn geschlossen wird oder bei ModalResult mrOK

[Kidi]

Hallo alle zusammen,
wie die Überschrift sagt, beschäftigt es mich wann die Formular Position gespeichert werden soll.
Wie handhabt ihr das, ich bin da ziemlich unsicher was der bessere Fall ist.

Mfg
Didi

[a.def]

Ich handhabe das so, dass die Größe und Position bei Resize oder Move meines Formulares in ein Array geschrieben wird.
Diese vier Werte speichere ich dann im OnClose.

Dazu kann man z.B. verwenden

Delphi-Quellcode:

procedure WMFormMoved(var msg: TWMMove); message WM_MOVE;
// und
procedure FormResize(Sender: TObject);

[Aviator]

Zitat von a.def:

Ich handhabe das so, dass die Größe und Position bei Resize oder Move meines Formulares in ein Array geschrieben wird.
Diese vier Werte speichere ich dann im OnClose.

Warum in einem Array zwischenspeichern wenn du die Werte direkt beim Beenden abrufen kannst? So wie du es jetzt machst läufst du nur unnötig Gefahr, dass du, aus welchem Grund auch immer, mal ein solches Event verpasst und deine Werte nicht mehr stimmen.

[a.def]

Zitat von Aviator:

Warum in einem Array zwischenspeichern wenn du die Werte direkt beim Beenden abrufen kannst? So wie du es jetzt machst läufst du nur unnötig Gefahr, dass du, aus welchem Grund auch immer, mal ein solches Event verpasst und deine Werte nicht mehr stimmen.

Das mit dem "erst beim Beenden speichern" hatte ich vorher so gemacht. Aber wenn Größe und Position eines Formulars welches nicht das Hauptformular ist gespeichert werden soll gab das Probleme (falsche Werte usw).
Daher speichere ich zwischen. Funktioniert wunderbar und die Zahlen sind immer aktuell.


Edith sagt
Man muss die alten Werte ja eh aus der Konfiguration auslesen und irgendwo zuweisen. Also ist das Zwischenspeichern kein Beinbruch

[Slipstream]

Zitat von a.def:

Das mit dem "erst beim Beenden speichern" hatte ich vorher so gemacht. Aber wenn Größe und Position eines Formulars welches nicht das Hauptformular ist gespeichert werden soll gab das Probleme (falsche Werte usw). Daher speichere ich zwischen. Funktioniert wunderbar und die Zahlen sind immer aktuell.

Was spricht dagegen, erstens zwei private Methode zum Lesen und Speichern von Formulargrösse und -position einzubauen, in der direkt diese fünf Parameter in Registry, Datenbank oder Inidatei gespeichert werden?

Und was spricht zweitens dagegen, diese Methode dann in der OnClose-Ereignisbehandlung aufzurufen?

Ich mach das schon immer so und hatte damit noch nie Probleme. Hier ein Beispiel, wie man aus einer Datenbank (die vielleicht auch von mehreren Clients verwendet wird), die individuellen Daten zur Wiederherstellung der individuellen Programmoptionen ausliest und wieder zurückschreibt, der Einfachheit halber reduziert auf Fensterposition, -grösse und Windowstate:

Delphi-Quellcode:

Procedure FormSoundSo.FormParamsRead;
begin
  Left := DM.QueryUser.FieldByName('SOUNDSO_LEFT').AsInteger;
  Top := DM.QueryUser.FieldByName('SOUNDSO_TOP').AsInteger;
  Width := DM.QueryUser.FieldByName('SOUNDSO_WIDTH').AsInteger;
  Height := DM.QueryUser.FieldByName('SOUNDSO_HEIGHT').AsInteger;
  if DM.QueryUser.FieldByName('SOUNDSO_MAX').AsBoolean then
     Windowstate := wsMaximized else
     Windowstate := wsNormal;
end;

Procedure FormSoundSo.FormParamsWrite;
var
  Maxi : Boolean;
begin
  Maxi := Windowstate = wsMaximized;
  Windowstate := wsNormal;
  DM.QueryUser.Edit;
  DM.QueryUser.FieldByName('SOUNDSO_LEFT').AsInteger := Left;
  DM.QueryUser.FieldByName('SOUNDSO_TOP').AsInteger Top;
  DM.QueryUser.FieldByName('SOUNDSO_WIDTH').AsInteger := Width;
  DM.QueryUser.FieldByName('SOUNDSO_HEIGHT').AsInteger := Height;
  DM.QueryUser.FieldByName('SOUNDSO_MAX').AsBoolean := Maxi;
  DM.QueryUser.Post;
end;

Procedure FormSoundSo.FormShow(Sender: TObject);
begin
  FormParamsRead;
end;

Procedure FormSoundSo.FormClose(Sender : TObject; Var Action : TCloseAction);
begin
  FormParamsWrite;
end;

Genauso (war mir jetzt zu aufwendig, das hier reinzutippen) würde man das beim Lesen von bzw. Schreiben in eine Inidatei oder Registry machen. Wenn du das jedesmal zwischenspeicherst, hast du das doppelt gespeichert. Ich weiß keinen Grund, diese Daten im Programm doppelt zu speichern.

[dataspider]

Hi

Ich finde es nützlich, die NormalPosition zu sichern und den State und zu prüfen, ob das Formular außerhalb des Screen ist.

ich habe dazu einen Form - Helper (Anlage).

Aufruf dann (z.B. in Datei speichern, bei mir landet das in der DB):

Delphi-Quellcode:

procedure TfrmMain.AfterConstruction;
Var
  AStream: TMemoryStream;
begin
  inherited;
  AStream := TMemoryStream.Create;
  try
    if FileExists(SFsBin) then
    begin
      AStream.LoadFromFile(SFsBin);
      LoadFormState(AStream);
    end;
  finally
    AStream.Free;
  end;
end;

procedure TfrmMain.BeforeDestruction;
Var
  AStream: TMemoryStream;
begin
  AStream := TMemoryStream.Create;
  try
    SaveFormState(AStream);
    AStream.SaveToFile(SFsBin);
  finally
    AStream.Free;
  end;
  inherited;
end;

Nicht vergessen: frm.Helper in Uses

Ist jetzt zwar mit Stream, aber das Prinzip ist sicher erkennbar.

Frank

[a.def]

Guck mal hier. So kann man auch auf außerhalb-des-sichtbaren-Bereichs prüfen.

Delphi-Quellcode:

procedure checkFormPosition(aFormToSetPos: TForm);
begin
 if Screen.MonitorFromWindow(aFormToSetPos.Handle, mdNull) = nil then
  begin
   // Form is outside of any monitor. Move to center of main monitor
   aFormToSetPos.Top := (Screen.Monitors[0].Height - aFormToSetPos.Height) div 2;
   aFormToSetPos.Left := (Screen.Monitors[0].Width - aFormToSetPos.Width) div 2;
  end;
end;

[rokli]

Hi Kidi,

ich verwende 2 Proceduren, mit denen ich die Werte in INI-Dateien schreibe (neben all den anderen Werten, die man so braucht):

Delphi-Quellcode:

procedure TfrmMain.p_IniRead;
{-------------------------------------------------------------------------------
   INI Datei einlesen
-------------------------------------------------------------------------------}
var
   Ini      : TIniFile;
begin
   Ini      := TIniFile.Create(ChangeFileExt( Application.ExeName, '.INI' ) );
   try
      Top       := Ini.ReadInteger( 'Windows Form Settings', 'Top', 100 );
      Left       := Ini.ReadInteger( 'Windows Form Settings', 'Left', 100 );
      Height    := Ini.ReadInteger( 'Windows Form Settings', 'Height', 100);
      Width    := Ini.ReadInteger( 'Windows Form Settings', 'Width', 100);
      if Ini.ReadBool( 'Windows Form Settings', 'InitMax', false ) then
         WindowState          := wsMaximized
      else
         WindowState          := wsNormal;
   finally
      Ini.Destroy;
   end;
end;

procedure TfrmMain.p_IniWrite;
{-------------------------------------------------------------------------------
   INI Datei wegschreiben
-------------------------------------------------------------------------------}
var
   Ini      : TIniFile;
begin
   Ini       := TIniFile.Create(ChangeFileExt( Application.ExeName, '.INI' ) );
   try
      Ini.WriteDateTime('Userdata', 'LastLogOut', now());
      Ini.WriteInteger( 'Windows Form Settings', 'Top', Top);
      Ini.WriteInteger( 'Windows Form Settings', 'Left', Left);
      Ini.WriteInteger( 'Windows Form Settings', 'Height', Height);
      Ini.WriteInteger( 'Windows Form Settings', 'Width', Width);
      Ini.WriteBool(    'Windows Form Settings', 'InitMax', WindowState = wsMaximized );
   finally
      Ini.Destroy;
   end;
end;

Den p_IniRead lese ich im OnCreate der Form und den p_IniWrite führe ich im OnClose aus. Und wenn Du die Positionen von weiteren Fenstern benötigst, dann erweiterst Du dir das entsprchend.

[rokli]

Ein großer Vorteil einer Ini-Datei ist, dass man ganz einfach z. B. den Form1.LEFT Wert ändern kann, und damit bei einer 2-Schirm Lösung das Programm von einem Bildschirm auf den anderen schieben kann, auch dann wenn man die Form nach dem Programmstart nicht sieht, weil sie außerhalb des Bildschirmes gelandet ist.

[uligerhardt]

Ich benutze für sowas GetWindowPlacement/SetWindowPlacement. Damit erspart man sich z.B. die Prüfung auf zwischenzeitlich nicht mehr vorhandene Monitore etc. Aufrufen tue ich das normalerweise im OnShow/OnHide.
Hier mal die Schreib-Routine als Beispiel:

Delphi-Quellcode:

procedure WriteWindowPlacement(AIni: TCustomIniFile; const Section, NamePrefix: string; Form: TCustomForm);
var
  wp: TWindowPlacement;
  sl: TStringList;
  s: string;
begin
  wp.length := SizeOf(TWindowPlacement);
  GetWindowPlacement(Form.Handle, @wp);

  sl := TStringList.Create;
  sl.Capacity := 9;
  try
    sl.Append(IntToStr(wp.showCmd));
    sl.Append(IntToStr(wp.ptMinPosition.X));
    sl.Append(IntToStr(wp.ptMinPosition.Y));
    sl.Append(IntToStr(wp.ptMaxPosition.X));
    sl.Append(IntToStr(wp.ptMaxPosition.Y));
    sl.Append(IntToStr(wp.rcNormalPosition.Left));
    sl.Append(IntToStr(wp.rcNormalPosition.Top));
    sl.Append(IntToStr(wp.rcNormalPosition.Right));
    sl.Append(IntToStr(wp.rcNormalPosition.Bottom));
    s := EncodeDelimitedText('(', ';', ')', sl); // Hier "sl" irgendwie in einen einzeiligen String wandeln (sl.DelimitedText oder so).
  finally
    sl.Free;
  end;

  AIni.WriteString(Section, NamePrefix + 'WindowPlacement', s);
end;