fenster der bildschirmauflösung anpassen - mathegenies wo seid ihr?

[markus lemcke]

tagchen,

wenn unter einer bildschirmauflöung von 640x480 programmiere und folgenden code den ich durch
rumprobieren herausfand ins oncreate-ereignis eines formulars einsetze, paßt sich das formular
der aktuellen bildschirmauflöung an:

const<br>
wide = 640;<br>
height = 480;<br>

var<br>
schrift:longint;<br>
begin<br>
{***********************Bildschirmauflösung******* *******************}<br>
if pixelsperinch = 96 then schrift := 0;<br>
{Wenn kleine Schriften eingestellt sind muß nichts<br>
abgezogen werden}<br>
if pixelsperinch = 120 then schrift := 28;<br>
{Wenn große Schriften eingestellt sind muß 25<br>
abgezogen werden. Diesen Wert habe ich durch<br>
"rumprobieren" herausgefunden}<br>
if (screen.width = wide) and (screen.height = height) then scaleby(100-schrift,100);<br>
{Wenn die aktuelle Bildschirmauflösung die gleiche ist wie die bei der das Programm<br>
programmiert wird, wird nicht skaliert, außer es sind große Systemschriften eingestellt.}<br>
if (screen.width = 800) and (screen.height = 600) and (pixelsperinch = 96)<br>
then scaleby(124,100);<br>

if (screen.width = 1024) and (screen.height = 768) and (pixelsperinch = 96)<br>
then scaleby(157,100);<br>

if (screen.width = 800) and (screen.height = 600) and (pixelsperinch = 120)<br>
then scaleby(124-25,100);<br>

if (screen.width = 1024) and (screen.height = 768) and (pixelsperinch = 120)<br>
then scaleby(157-32,100);<br>
{***********************Bildschirmauflösung******* *******************}<br>
end;<br>

jetzt programmiere ich aber auf 800x600 und jetzt klappt es nicht mehr. statt wieder rumprobieren<br>
hätte ich gerne eine mathematische universallösung um bei jeder bildschirmauflösung und schrift-<br>
größe den richtigen wert heraus zu finden.<br>

wer kann mir helfen??????<br>

mfg

markus

[DBR]

Vielleicht kannst Du damit was anfangen:
<br>
<pre>
const
waag=640;
senk=480;

procedure TForm1.FormCreate(Sender: TObject);
begin
umrbreit:=screen.width / waag;
umrhoch:=screen.Height / senk;
width:=round(width * umrbreit);
height:=round(height * umrhoch);
end;
</pre>
<br>
gruss DB

[Gerd Paulus]

Ich habe das Problem seit Delphi 1 so gelöst:
Zur Verfügung stehenden Platz ermitteln:

Wenn ich mit MDI-Fenstern arbeite im OnShow-Ereignis des
Hauptformulars (fsMDIForm)

iFormWidth:=Width-1;
iFormHeight:=Height-1;

sonst die Bildschirmauflösung mit
iFormWidth:=Screen.Width-1;
iFormHeight:=Screen.Height-1;

danach rufe ich im OnCreate-Ereignis des zu vergrößernden Formulars folgende Procedure auf:

{ Formular an vorhandenen Platz anpassen }
InitForm.ScaleForm(Self, iFormWidth, iFormHeight, 800, 600);

Die Procedure ScaleForm ist in einer Unit abgelegt, so dass Sie von allen Formularen aus aufgerufen werden kann. In dieser sind auch die Variablen iFormWidth und iFormHeight deklariert, so dass ich nur in meinem Hauptformular den zur Verfügung stehenden Platz ermittle.

unit U_InitFo;

interface

uses
Forms, ExtCtrls, Controls, Graphics, Dialogs, Classes,
Windows, SysUtils, Buttons, StdCtrls, Dblup2, comctrls;

type
TInitForm = class(TComponent)
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
procedure ScaleForm(const Form:TForm; const iWSoll, iHSoll, iWOrg, iHOrg: Integer);
end;

var
InitForm : TInitForm;
iFormWidth,
iFormHeight : Integer;

implementation

procedure TInitForm.ScaleForm(const Form:TForm; const iWSoll, iHSoll, iWOrg, iHOrg: Integer);
{************************************************* *******************}
{ ScaleForm }
{--------------------------------------------------------------------}
{ Erstellung : 26. 5.98 }
{ Letzte Änderung : 26. 5.98 }
{--------------------------------------------------------------------}
{ Paßt das Formular an den aktuellen Bildschirm an }
{ iWSoll und iHSoll werden im Startfenster gesetzt. Dadurch werden }
{ die Rahmen von Windows 95 berücksichtigt. }
{ Einstellungen im Objektinspektor: }
{ Position = SreenCenter }
{ Scaled = false }
{ WindowState = wsMaximized }
{--------------------------------------------------------------------}
{ Übergabeparameter }
{ Form = Formular, das angepaßt werden soll }
{ iWSoll = Breite, auf die Formulat max. vergrößert werden kann }
{ iHSoll = Höhe, auf die Formulat max. vergrößert werden kann }
{ iWOrg = Breite, in der das Formulars erstellt wurde }
{ iHOrg = Höhe, in der das Formulars erstellt wurde }
{************************************************* *******************}
var
i, j : Integer;
rScaleF : Real; { Skalierfaktor,mit dem Formular verändert wurde }

begin
with Form do
begin
if iWSoll/iWOrg < iHSoll/iHOrg then
rScaleF:=iWSoll/iWOrg
else
rScaleF:=iHSoll/iHOrg;
Form.ScaleBy(round(10000*rScaleF), 10000);

{ Bei alle TDBLookupComboPlus-Komponenten die Listenbreite }
{ entsprechend des Scalefaktors verbreitern }
for I:= 0 to ComponentCount -1 do
begin
if Components[I] is TDBLookupComboPlus then
{ DropDown-Breite wird beim scalieren leider nicht verändert }
TDBLookupComboPlus(Components[I]).DropDownWidth:=
round(TDBLookupComboPlus(Components[I]).DropDownWidth*rScaleF)
else if Components[I] is TStatusBar then
{ Panel-Breite wird beim scalieren leider nicht verändert }
for j:=0 to TStatusBar(Components[I]).Panels.Count-1 do
TStatusBar(Components[I]).Panels[j].Width:=round(TStatusBar(Components[I]).Panels[j].Width*rScaleF);
end;
end;
end;

end

[Gerd Paulus]

Oje, das sah ja übel aus. Mit der Formatierung habe ich noch ein Problem. Einfach den Quelltext kopieren reicht anscheinen nicht:

Ich habe das Problem seit Delphi 1 so gelöst: Zur Verfügung stehenden Platz ermitteln:

Wenn ich mit MDI-Fenstern arbeite im OnShow-Ereignis des Hauptformulars (fsMDIForm)

iFormWidth:=Width-1;
iFormHeight:=Height-1;

sonst die Bildschirmauflösung mit

iFormWidth:=Screen.Width-1;
iFormHeight:=Screen.Height-1;

danach rufe ich im OnCreate-Ereignis des zu vergrößernden Formulars folgende Procedure auf:

{ Formular an vorhandenen Platz anpassen } InitForm.ScaleForm(Self, iFormWidth, iFormHeight, 800, 600);

Die Procedure ScaleForm ist in einer Unit abgelegt, so dass Sie von allen Formularen aus aufgerufen werden kann. In dieser sind auch die Variablen iFormWidth und iFormHeight deklariert, so dass ich nur in meinem Hauptformular den zur Verfügung stehenden Platz ermittle.

unit U_InitFo;

interface

uses Forms, ExtCtrls, Controls, Graphics, Dialogs, Classes, Windows, SysUtils, Buttons, StdCtrls, Dblup2, comctrls;

type
TInitForm = class(TComponent)
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
procedure ScaleForm(const Form:TForm; const iWSoll, iHSoll, iWOrg, iHOrg: Integer);
end;

var
InitForm : TInitForm;
iFormWidth, iFormHeight : Integer;

implementation

procedure TInitForm.ScaleForm(const Form:TForm; const iWSoll, iHSoll, iWOrg, iHOrg: Integer); {************************************************* ******************}
{-------------------------------------------------------------------}
{ Paßt das Formular an den aktuellen Bildschirm an }
{ iWSoll und iHSoll werden im Startfenster gesetzt. Dadurch werden }
{ die Rahmen von Windows 95 berücksichtigt. }
{ Einstellungen im Objektinspektor: }
{ Position = SreenCenter }
{ Scaled = false }
{ WindowState = wsMaximized }
{------------------------------------------------------------------}
{ Übergabeparameter }
{ Form = Formular, das angepaßt werden soll }
{ iWSoll = Breite, auf die Formulat max. vergrößert werden kann }
{ iHSoll = Höhe, auf die Formulat max. vergrößert werden kann }
{ iWOrg = Breite, in der das Formulars erstellt wurde }
{ iHOrg = Höhe, in der das Formulars erstellt wurde } {************************************************* *******************}var
i, j : Integer;
rScaleF : Real; { Skalierfaktor,mit dem Formular verändert wurde }

begin
with Form do
begin
if iWSoll/iWOrg < iHSoll/iHOrg then
rScaleF:=iWSoll/iWOrg
else
rScaleF:=iHSoll/iHOrg;
Form.ScaleBy(round(10000*rScaleF), 10000);
end;

end