Formulargröße auf HighDPI-Monitor speichern

[DieDolly]

Mir ist das gerade zum ersten mal aufgefallen.
Verschiebe ich mein Formular auf meinen 150% DPI-Monitor und beende das Programm, wird die Formulargröße viel zu groß gespeichert.
Was vorher width 1000 war ist jetzt 1500. Scheint normal zu sein. Aber wenn ich das Programm jetzt erneut starte, ist das Fenster nochmal größer als 1500.

Muss man beim Speichern unter HighDPI irgendwas beachten?

[Uwe Raabe]

Zitat:

Zitat von DieDolly (Beitrag 1429627)

Verschiebe ich mein Formular auf meinen 150% DPI-Monitor und beende das Programm, wird die Formulargröße viel zu groß gespeichert.
Was vorher width 1000 war ist jetzt 1500. Scheint normal zu sein.

Würde ich auch so sehen: 1000 * 150% = 1500

Zitat:

Zitat von DieDolly (Beitrag 1429627)

Aber wenn ich das Programm jetzt erneut starte, ist das Fenster nochmal größer als 1500.

Vermutlich setzt du die Formulargröße bevor die Skalierung erfolgt. Es ist schon sehr wichtig, wann genau diese Werte gesetzt werden.

Zitat:

Zitat von DieDolly (Beitrag 1429627)

Muss man beim Speichern unter HighDPI irgendwas beachten?

Ich würde die Größe immer vor dem Speichern auf 100% umrechnen, dann hast du auch kein Problem, sollte der Monitor zwischenzeitlich mal eine andere DPI bekommen.

Schwieriger wird es da schon bei der Position. Andererseits sollte man beim Wiederherstellen von Position und Größe immer noch auf die aktuellen Bereiche achten, sonst ist das Form irgendwann mal halb oder ganz verschwunden.

[Bernhard Geyer]

Da wird wohl dein Code zum Speichern und wiederherstellen der Fenstergrößen falsch sein.
Ich würde die Speicherung normiert auf 96 dpi durchführen und beim Laden prüfen was du vor dir hast.

[DieDolly]

Wie führe ich eine solche normierte 96 DPI Speicherung aus?

Ich übergebe beim Speichern der Formulargröße Form123 an die entsprechende Prozedur, die anschließend AForm.Width und AForm.Height in eine Datei schreibt.

[Redeemer]

Ich denke übrigens, dass Delphi z.B. aus 125% (120dpi/96dpi) 146% macht... Warum ist das so?

[Bernhard Geyer]

Prüfe auf welchen Monitor Formular liegt (Property Monitor) und welche DPI-Einstellung dieser hat.

[Uwe Raabe]

Zitat:

Zitat von Redeemer (Beitrag 1429636)

Ich denke übrigens, dass Delphi z.B. aus 125% (120dpi/96dpi) 146% macht... Warum ist das so?

Und wieso denkst du das?

[DieDolly]

Zitat:

Ich denke übrigens, dass Delphi z.B. aus 125% (120dpi/96dpi) 146% macht... Warum ist das so?

Sowas denke ich auch. Kann es aber nicht belegen.

Zitat:

Prüfe auf welchen Monitor Formular liegt (Property Monitor) und welche DPI-Einstellung dieser hat.

Was stelle ich dann mathematisch mit diesen beiden Informationen an?

Ich habe schon Dinge versucht wie NeueBreite = Prozentwert aus (AktuelleBreite, (AktuelleDPI minus 96) ) aber das klappt nicht und gibt einen Wert von rund 700 zurück statt 1000.

Ganz genau genommen ist mein Formular bei 96 DPI 1050 Pixel breit. Nach dem Rüberziehen und Speichern auf einen 144 DPI (150%) Monitor werden daraus 1575. Das sind 33,4% mehr.
Wie ich da wieder auf 1050 komme ist mir ein Geheimnis.

[EWeiss]

Zitat:

wird die Formulargröße viel zu groß gespeichert.

Speicher sie so ab wie sie ohne DPI ist.

Und lade sie so ein Windows Skaliert dann automatisch. oder?
Wenn du die größe inklusive DPI abspeicherst nun ja dann skaliert Windows immer höher.

gruss

[DieDolly]

Zitat:

Speicher sie so ab wie sie ohne DPI ist.

Ich hole mir die aktuellen Formularwerte Width und Height direkt vom TForm beim speichern.

Ich würde die gerne umrechnen zurück auf 96 DPI aber ich weiß leider nicht wie. Versuche ergeben (wie oben geschrieben) sehr komische Werte die nicht korrekt sein können.

Zitat:

Wenn du die größe inklusive DPI abspeicherst nun ja dann skaliert Windows immer höher.

Genau das ist der Fall aktuell.

[Michael II]

Zitat:

Ganz genau genommen ist mein Formular bei 96 DPI 1050 Pixel breit. Nach dem Rüberziehen und Speichern auf einen 144 DPI (150%) Monitor werden daraus 1575. Das sind 33,4% mehr.
Wie ich da wieder auf 1050 komme ist mir ein Geheimnis.

Hallo DieDolly

von einer Länge 1050 auf 1575 sind's nicht 33,4% mehr sondern 50%. Genau so ist es bei den DPI Werten: Von 96 auf 144 sind's auch 50% mehr.

Wenn du auf System 1 Auflösung DPI1 und auf System 2 DPI2 hast, und ein Formular auf System 1 l1 lang ist, dann hat es auf System 2 eine Länge von l2 := (DPI2/DPI1)*l1. In deinem Fall l2=144/96*1050=1.5*1050=1575.

[EWeiss]

Ich gebe mal ein kleines Beispiel wie ich das in meinem KVPlayer mache (c++) keine Ahnung ob du das dann so auf VCL umsetzen kannst.

Code:

SetRect(&rc, 0, 0, dpi(CLIENT_WIDTH), dpi(CLIENT_HEIGHT));
AdjustWindowRectEx(&rc, dwStyle, FALSE, 0);

CLIENT_WIDTH und CLIENT_HEIGHT ist die normale größe ohne DPI.

Code:

#define CLIENT_WIDTH 960
#define CLIENT_HEIGHT 658

Ich rechne DPI hoch wie folgt.

Code:

long dpi(IN long nPix) {
    static float ratio;
    if (ratio == 0) {
        HDC hDC = GetDC(0); ratio = (GetDeviceCaps(hDC, LOGPIXELSX) / 96.0f); ReleaseDC(0, hDC); 
    }
    return  (long)(nPix * ratio);
}

Du musst nun lediglich die DPI in umgekehrter Reihenfolge zurück rechnen das wars schon.
Ich denke damit kommst du zurecht.

gruss

[DieDolly]

Und wie rechne ich zurück (auf 96 DPI), dass ich so abspeichern kann, dass Windows nicht bei jedem Start neu hochskaliert? :(

Leider verstehe ich das da oben nicht.

Was funktioniert ist, das Formular kurz vorher zurück auf 96 DPI zu skalieren ABER ob das schön ist ... ich bezweifle es

Delphi-Quellcode:

// Routine zum beenden und speichern des Programms ...

ZuSchließendeUndSpeicherndeForm.ScaleBy(96, Aktuelle DPI des Monitors auf dem das Form liegt);

Das ergibt dann zwar 1057 Pixel statt 1050 aber damit kann man leben.

[EWeiss]

Zitat:

Zitat von DieDolly (Beitrag 1429653)

Und wie rechne ich zurück (auf 96 DPI), dass ich so abspeichern kann, dass Windows nicht bei jedem Start neu hochskaliert? :(

Leider verstehe ich das da oben nicht.

habe ich doch gepostet ..

Code:

(GetDeviceCaps(hDC, LOGPIXELSX) / 96.0f);

so wird die neue gesetzt das ins Gegenteil umlegen und fertig.

Code:

nPix * Ratio

Code:

nPix div Ratio

Oder?

gruss

[DieDolly]

Leider kenne ich mich mit C++ kein bisschen aus. Deswegen sagen mir weder diese Funktionen was noch die Variablen.

[Uwe Raabe]

Zitat:

Zitat von DieDolly (Beitrag 1429641)

(AktuelleDPI minus 96)

Wies denn Minus? Es geht doch um das Verhältnis von AktuelleDPI zu 96.

Zitat:

Zitat von DieDolly (Beitrag 1429650)

Ich würde die gerne umrechnen zurück auf 96 DPI aber ich weiß leider nicht wie.

Delphi-Quellcode:

<zu speichernder Wert> := MulDiv(<aktueller Wert>, 96, <aktuelle DPI>);

[Michael II]

Hallo Dolly, was an der Formel verstehst du nicht?


Nimm ein System 1 mit DPI1 und ein System 2 mit DPI2.

Formularlänge auf System 1 sei l1 und auf System 2 l2.

Wenn DPI1 und DPI2 bekannt sind und das Formular mit Länge l1 momentan auf System 1 liegt, dann gilt für die entsprechende Länge l2 auf System 2 (zum Beispiel die Breite oder die Höhe oder die Diagonale ;-)):

l2 := DPI2/DPI1*l1 (1)

und umgekehrt kannst du natürlich auch nach l1 auflösen:

11 := DPI1/DPI2*l2 (2)


In deinem Fall: Dein Formular befindet sich auf System 2 mit DPI2=144 und hat eine Breite von w=1575. Nun willst du die Breite auf System 1 bestimmen. Es gilt Formel 2 von oben:

Du berechnest
l1 := 96/144*1575 = 1050

Das Formular hat also auf System 1 eine Breite von l1=1050.

Was nebenbei und nicht ganz zufällig genau dem Wert entspricht, den du gemessen hast ;-).

[EWeiss]

Zitat:

Zitat von DieDolly (Beitrag 1429656)

Leider kenne ich mich mit C++ kein bisschen aus. Deswegen sagen mir weder diese Funktionen was noch die Variablen.

Na dann..

Delphi-Quellcode:

function dpi(nPix: Integer): Integer; (oder(LongInt ))
var
  ratio: Single;
  DC: HDC;
begin

  if (ratio = 0) then
  begin
    DC := GetDC(0);
    ratio := (GetDeviceCaps(DC, LOGPIXELSX) / 96.0);
    ReleaseDC(0, hDC);
  end;
  result := nPix * ratio;
end;

Delphi-Quellcode:

 ratio: Single;

global definieren.
Dafür brauche ich nicht mal ein Manifest.. muss halt nur drauf achten das ich jedes Control durch diese Funktion jage.

Zitat:

Du berechnest
l1 := 96/144*1575 = 1050

OH schreck das macht doch die Funktion GetDeviceCaps da muss man nichts berechnen.
GetDC(0) ist das DC des Desktop.
Von der Auflösung des Desktop wird dann über GetDeviceCaps(GetDeviceCaps(DC, LOGPIXELSX)) die DPI zurückgegeben.
Diese noch durch 96.0 teilen und fertig.

gruss

[Uwe Raabe]

Zitat:

Zitat von EWeiss (Beitrag 1429659)

Delphi-Quellcode:

    DC := GetDC(0);
    ratio := (GetDeviceCaps(DC, LOGPIXELSX) / 96.0f);

Das gibt aber nicht zwingend die aktuelle DPI des Monitors an, auf dem das Form gerade sichtbar ist, oder?

Ich hatte es so verstanden, daß es genau darum ging:

Zitat:

Zitat von DieDolly (Beitrag 1429627)

Verschiebe ich mein Formular auf meinen 150% DPI-Monitor und beende das Programm, wird die Formulargröße viel zu groß gespeichert.

[EWeiss]

Zitat:

Das gibt aber nicht zwingend die aktuelle DPI des Monitors an, auf dem das Form gerade sichtbar ist, oder?

Klar siehe

Zitat:

Number of pixels per logical inch along the screen width. In a system with multiple display monitors, this value is the same for all monitors.

Zitat:

Number of pixels per logical inch along the screen height. In a system with multiple display monitors, this value is the same for all monitors.

gruss

[DieDolly]

Ich habe mir eure Funktionen jetzt nochmal genau angeguckt, selber nachgerechnet und ja, ich bin dumm wie Stroh. ich bin halt ein mathematisches Anti-Wunderkind im erhöhten Alter :thumb:
Ich versuche hier die ganze Zeit Prozentrechnung und wundere mich, warum ich nicht zurück auf 1050 komme.

MultiDiv scheint genau das zu tun, was Michael schrieb. Leider kann man in die Quelltexte von MultiDiv nicht reingucken. Wenn ich das richtig verstehe, ist MultiDiv auch plattformspezifisch.

Meine zwei neuen Funktionen, die mir sicher oft noch weiterhelfen werden

Delphi-Quellcode:

// Plattformunabhängiges MultiDiv, Uwe Raabe, Michael II@ DelphiPraxis.net
function TMathUtils.MulDiv(nNumber, nNumerator, nDenominator: Integer): Integer;
begin
 Result := Round((nNumber / nNumerator) * nDenominator);
end;

// Diese Funktion nutze ich aktuell dort, wo ich vorher nur ScaleBy nutzte
procedure TFormUtils.ScaleForm(const Form: TForm; const NewDPI, CurrentDPI: Integer);
begin
 if NewDPI <> CurrentDPI then
  begin
   SendMessage(Form.Handle, WM_SETREDRAW, WPARAM(False), 0); // LockWindow nutze ich nicht wegen, siehe ***
   try
    aForm.ScaleBy(NewDPI, CurrentDPI);
   finally
    SendMessage(Form.Handle, WM_SETREDRAW, WPARAM(True), 0);
   end;
  end;
end;

***

Zitat:

LockWindowUpdate was designed to stop drawing for drag and drop, it goes a bit further than WM_SETREDRAW because it could make assumptions about what the user was doing. One assumption was that since a drag and drop was occurring, window moving could be disabled/ignored. You can still drag a window around that has WM_SETREDRAW set to false.

@https://stackoverflow.com/questions/3792217/how-can-i-disable-screen-update-which-updating-a-lot-of-controls

[EWeiss]

Versteh nicht was du da tust aber gut..
Was hat das verhindern von Zeichnungs Operationen nun mit dem Skalieren der Form zu tun?
Ok bin raus das driftet ab.

gruss

[DieDolly]

Zitat:

Was hat das verhindern von Zeichen Operationen nun mit dem Skalieren der Form zu tun?

Als dreckigen Workaround hatte ich vorher ScaleBy benutzt. Und um das sichtbare Neuzeichnen zu verbergen, habe ich mir diese Prozedur geschrieben.

[Uwe Raabe]

Zitat:

Number of pixels per logical inch along the screen width. In a system with multiple display monitors, this value is the same for all monitors.

Das unterstreicht meinen Einwand aber doch gerade! Der Wert ist für alle Monitore derselbe, also bekommt man eben nicht den für den jeweiligen Monitor relevanten Wert, sondern einen systemweit gültigen.

[EWeiss]

Zitat:

sondern einen systemweit gültigen.

Nun gut reicht das nicht?
Ich habe kein Problem da ich mich NUR mit einem rumschlage.
Ich möchte nicht im Elektrosmog untergehen.

gruss

[DieDolly]

Früher hatte ich auch nur einen Monitor. Mittlerweile einen 24" und einen 21". Den zweiten möchte ich nicht mehr missen.
1x Delphi links, 1x rechts oder auf dem anderen Sublime oder irgendwas anderes.

[DieDolly]

Zitat:

Zitat von DieDolly (Beitrag 1429662)

Ich habe mir eure Funktionen jetzt nochmal genau angeguckt, selber nachgerechnet und ja, ich bin dumm wie Stroh. ich bin halt ein mathematisches Anti-Wunderkind im erhöhten Alter :thumb:
Ich versuche hier die ganze Zeit Prozentrechnung und wundere mich, warum ich nicht zurück auf 1050 komme.

MultiDiv scheint genau das zu tun, was Michael schrieb. Leider kann man in die Quelltexte von MultiDiv nicht reingucken. Wenn ich das richtig verstehe, ist MultiDiv auch plattformspezifisch.

Meine zwei neuen Funktionen, die mir sicher oft noch weiterhelfen werden

Delphi-Quellcode:

// Plattformunabhängiges MultiDiv, Uwe Raabe, Michael II@ DelphiPraxis.net
function TMathUtils.MulDiv(nNumber, nNumerator, nDenominator: Integer): Integer;
begin
 Result := Round((nNumber / nNumerator) * nDenominator);
end;

// Diese Funktion nutze ich aktuell dort, wo ich vorher nur ScaleBy nutzte
procedure TFormUtils.ScaleForm(const Form: TForm; const NewDPI, CurrentDPI: Integer);
begin
 if NewDPI <> CurrentDPI then
  begin
   SendMessage(Form.Handle, WM_SETREDRAW, WPARAM(False), 0); // LockWindow nutze ich nicht wegen, siehe ***
   try
    aForm.ScaleBy(NewDPI, CurrentDPI);
   finally
    SendMessage(Form.Handle, WM_SETREDRAW, WPARAM(True), 0);
   end;
  end;
end;

Die MulDiv Funktion muss ich korrigieren. Sie war leider falsch. Nicht, dass einer die falsche kopiert. Richtig lautet sie

Delphi-Quellcode:

class function TMathUtils.MulDiv(nNumber, nNumerator, nDenominator: Integer): Integer;
begin
 Result := Round((nNumber * nNumerator) / nDenominator);
end;

[Michael II]

Ja mir war aufgefallen, dass deine nicht 100%ig jener von Delphi entspricht, aber meistens wohl genügt ;-).

Delphi setzt dies um:
https://docs.microsoft.com/en-us/win...winbase-muldiv

D.h. deine nachgebaute Funktion sollte zum Beispiel in gewissen Fällen -1 ausgeben.

Fürs Runden solltest du nicht round verwenden. round(x) rundet .5 immer auf die gerade Zahl, welche x am nächsten liegt. Beispiel 0.5 wird auf 0 gerundet, 1.5 auf 2, 2.5 auf 2, 3.5 auf 4. MulDiv macht's anders. Schau dir zum Beispiel trunc an.

Zum Runden in Delphi gibt's hier Infos.

[DieDolly]

Verbesserung

Delphi-Quellcode:

class function TMathUtils.MathRound(X: Extended): Int64; // Bei stackoverflow gefunden, für die Sammlung. Obwohl Trunc dasselbe macht.
begin
 if X >= 0 then
  Result := Trunc(X + 0.5)
 else
  Result := Trunc(X - 0.5);
end;

class function TMathUtils.MulDiv(nNumber, nNumerator, nDenominator: Integer): Integer;
begin
 Result := Trunc((nNumber * nNumerator) / nDenominator);
end;

[EWeiss]

Zitat:

Zitat von DieDolly (Beitrag 1430257)

Verbesserung

Delphi-Quellcode:

class function TMathUtils.MathRound(X: Extended): Int64; // Bei stackoverflow gefunden, für die Sammlung. Obwohl Trunc dasselbe macht.
begin
 if X >= 0 then
  Result := Trunc(X + 0.5)
 else
  Result := Trunc(X - 0.5);
end;

class function TMathUtils.MulDiv(nNumber, nNumerator, nDenominator: Integer): Integer;
begin
 Result := Trunc((nNumber * nNumerator) / nDenominator);
end;

Danke.. Werde ich sicherlich mal benötigen.

gruss

[Michael II]

Ja du musst aber natürlich in deiner MulDiv() deine Rundungsfunktion MathRound() verwenden - so wie von dir gepostet verwendest du trunc().

Also so:

Delphi-Quellcode:

 Result := MathRound( (nNumber * nNumerator) / nDenominator);

Weiter musst du den Fall nDenominator=0 abfangen (Result := -1) und auch mögliche Überläufe ((nNumber * nNumerator) / nDenominator kann so gross werden, dass das Resultat nicht in einem integer Platz hat).


Weiteres Problem: Möglicher integer Überlauf bei der Multiplikation nNumber * nNumerator

Deine MulDiv Funktion liefert zum Beispiel für

Delphi-Quellcode:

var x : integer;
begin
    x := MulDiv( maxint div 2, maxint div 2, maxint div 2 );

x = -2, müsste aber natürlich maxint div 2 zurückgeben.

Schreibe deshalb int64(nNumber) * int64(nNumerator) statt nNumber * nNumerator, sonst hast du wenig Freude, wenn nNumber * nNumerator > maxint.

OK für deinen "Fenster-Fall" wirst du kaum je solche Werte als Argumente haben. Aber wenn du MulDiv nachbilden willst, dann musst du darauf achten.

[DieDolly]

Ich hätte nicht gedacht, dass die windowseigene Muldiv() das alles berücksichtigt. Was berücksichtigt die denn noch? Denn die ist scheinbar plattformspezifisch.

[Fritzew]

Zitat:

Schreibe deshalb int64(nNumber) * int64(nNumerator) statt nNumber * nNumerator, sonst hast du wenig Freude, wenn nNumber * nNumerator > maxint.

oder verwende gleich die
MulDivInt64(.....) aus der System Unit. Die ist crossplatform angelegt sollte also keine Problem machen.

[DieDolly]

Zitat:

Zitat von Fritzew (Beitrag 1430262)

Zitat:

Schreibe deshalb int64(nNumber) * int64(nNumerator) statt nNumber * nNumerator, sonst hast du wenig Freude, wenn nNumber * nNumerator > maxint.

oder verwende gleich die
MulDivInt64(.....) aus der System Unit. Die ist crossplatform angelegt sollte also keine Problem machen.

Warum Unmengen an CPU Befehlszyklen verbraten, wenn es auch mit weniger geht?

[Fritzew]

Zitat:

Zitat von DieDolly (Beitrag 1430263)

Warum Unmengen an CPU Befehlszyklen verbraten, wenn es auch mit weniger geht?

Gefühlt oder gemessen?

[DieDolly]

Habe kurz in den Code reingeguckt und der scheint grob überschlagen 10x länger zu sein als der aus diesem Thread hier.