High DPI/de: what changed

Revision 0 to 1. Removed lines have a minus sign; added lines have a plus sign.

Title: High DPI/de

New		Line
1	+	\
2	+	Zurück zu den [[Additional information/de\|Zusätzlichen Informationen]].\
3	+	\
4	+	== Definition == DPI (dots per inch = Punkte pro Zoll) ist das Verhältnis zwischen Größe in Pixeln und der tatsächlichen Anzeigegröße. Hier steht "Punkt" (dot) als Äquivalent für Pixel in der Druckterminologie. Anwendungen können entweder Pixelgrößen verwenden, oder die aktuelle Anzeigegröße berücksichtigen. In diesem zweiten Fall sind die Größen in "Punkten" angegeben.
5	+
6	+	Unter Windows Vista und höher ist es möglich, das DPI-Verhältnis zu ändern, um Elemente größer darzustellen. High DPI ("Hochauflösung") bedeutet jede benutzerdefinierte Textgröße (DPI) mit mehr als 96 DPI (Standard) \[<http://msdn.microsoft.com/en-us/library/ee318406(VS.85>).aspx *\].
7	+
8	+	High DPI awareness (= Berücksichtigung der Hochauflösung) bedeutet also, dass eine Anwendung diese DPI-Einstellungen beachtet.
9	+
10	+	## Pixel und Punkte
11	+
12	+	Zum Beispiel bedeutet 300 DPI, dass es 300 Pixel (oder dot) pro Inch gibt. Wenn aber dafür 72 Punkte pro Inch definiert sind, so bedeutet das:
13	+
14	+	300 Pixel ↔ 1 Inch
15	+
16	+	300/72 Pixel ↔ 1 Punkt
17	+
18	+	4.16 Pixel ↔ 1 Punkt
19	+
20	+	Im Fall von 96 DPI gilt:
21	+
22	+	72 Pixel ↔ 1 Inch
23	+
24	+	1.33 Pixel ↔ 1 Punkt
25	+
26	+	und bei 144 DPI:
27	+
28	+	144 Pixel ↔ 1 Inch
29	+
30	+	2 Pixel ↔ 1 Punkt
31	+
32	+	## Benutzerdefinierte Textgröße (High DPI) in Windows festlegen
33	+
34	+	Unter Windows 7 gehen Sie zu Systemsteuerung \> Darstellung und Anpassung \> Anzeige.
35	+
36	+	Wählen Sie: Kleiner 100% (Standard), Mittel 125% oder Größer 150%. Wenn Sie 100% (96 DPI) ausgewählt haben, ist das die Standardeinstellung von Windows für den DPI-Wert, aber nicht High DPI.
37	+
38	+	Bei 125% (120 DPI) ist die Option "DPI-Skalierung im Stil von Windows XP verwenden" aktiviert, Anwendungen werden unter diesen Einstellungen wie bei Windows XP skaliert.
39	+
40	+	Bei 150% (144 DPI) ist die Option "DPI-Skalierung im Stil von Windows XP verwenden" deaktiviert (die DPI Virtualisierung ist aktiviert). Anwendungen, die mit dieser Einstellung ablaufen, müssen selbst die Hochauflösung verwalten ("High DPI Awareness") ansonsten liefert die Skalierung des Systems ein verwischtes, unscharfes Bild.
41	+
42	+	Sie können den DPI-Wert auch mit dem Dialog "Benutzerdefinierte Textgröße (DPI) festlegen" einstellen und die DPI Virtualisierung aktivieren/ deaktivieren.
43	+
44	+	## Beispiel
45	+
46	+	Hier ist ein Formular mit undefinierter Fontgröße (Size ist auf 0 gesetzt; das ist der Vorgabewert). Entworfen bei 96 DPI (100%), sieht das so aus:
47	+
48	+	<figure>
49	+	<img src="Testdpi100.png" title="Testdpi100.png" />
50	+	<figcaption>Testdpi100.png</figcaption>
51	+	</figure>
52	+
53	+	Jetzt mit 120 DPI (125%) wird es zu:
54	+
55	+	<figure>
56	+	<img src="Testdpi125.png" title="Testdpi125.png" />
57	+	<figcaption>Testdpi125.png</figcaption>
58	+	</figure>
59	+
60	+	Wie Sie sehen wird die Schrift größer und abgeschnitten. Der Fenstertitel wird größer, aber der Clientbereich behält seine Abmessungen. Beachten Sie, dass diese Größenänderungen beim Einsatz verschiedener Windows-Themen oder eines anderen Betriebssystems auftreten können.
61	+
62	+	Um dies zu vermeiden setzen Sie die Schriftgröße (Size) auf einen Wert ungleich 0. Beachten Sie, dass Font.Size in Punkten angegeben wird und Font.Height in Pixel. Tatsächlich wird nur der Wert von Font.Height gespeichert und Font.Size ändert sich abhängig vom aktuellen DPI-Wert. Wenn wir also Font.Size angeben, wird die Schriftgröße auf eine bestimmte Größe in Pixeln festgelegt.
63	+
64	+	Ber einer fixierten Schriftgröße von 9 Punkt bei 96 DPI (100%), erhalten wir dies:
65	+
66	+	<figure>
67	+	<img src="Testdpi100fixedM12P9.png" title="Testdpi100fixedM12P9.png" />
68	+	<figcaption>Testdpi100fixedM12P9.png</figcaption>
69	+	</figure>
70	+
71	+	Wenn jetzt das selbe Programm bei 120 DPI (125%) läuft, wird daraus:
72	+
73	+	<figure>
74	+	<img src="Testdpi125fixedM12P9.png" title="Testdpi125fixedM12P9.png" />
75	+	<figcaption>Testdpi125fixedM12P9.png</figcaption>
76	+	</figure>
77	+
78	+	Das Ergebnis ist fast das selbe. Die Titelzeile ist größer, aber der Clientbereich und dessen Schriftgröße blieben gleich. Beachten Sie aber, dass sich die Punktgröße der Titelschriftart geändert hat.
79	+
80	+	Als Schlussfolgerung ist es möglich, Inkonsistenzen der Anzeige durch Festlegung der Schriftgrößen zu vermeiden. Aber wir berücksichtigen dabei nicht, dass die grafischen Elemente durch die aktuellen DPI des Bildschirms weniger Platz lassen. Bei Berücksichtigung der Hochauflösung ist es möglich, dass sich Anwendungen so verhalten, als wüßten sie die wirkliche Größe der Pixel.
81	+
82	+	## Beispiel (Windows)
83	+
84	+	[CPickSniff](http://sourceforge.net/projects/cpicksniff2/) ist eine Anwendung zum Abfragen der Farben am Bildschirm. Wir nehmen sie als Beispiel, wie sich High DPI unter Windows auswirkt.
85	+
86	+	### Standard DPI
87	+
88	+	Das ist das Programm bei 96 DPI (100%). Es ist der Vorgabemodus, in dem keine Skalierung nötig ist.
89	+
90	+	<figure>
91	+	<img src="cpicksniff_defaultdpi.png" title="cpicksniff_defaultdpi.png" />
92	+	<figcaption>cpicksniff_defaultdpi.png</figcaption>
93	+	</figure>
94	+
95	+	### Windows DPI Skalierung
96	+
97	+	Dies ist das gleiche Programm bei 144 DPI (150%) ohne ein Manifest, also skaliert Windows es wie eine Bitmap. Das Ergebnis ist ein verwaschenes Bild.
98	+
99	+	<figure>
100	+	<img src="cpicksniff_blured.png" title="cpicksniff_blured.png" />
101	+	<figcaption>cpicksniff_blured.png</figcaption>
102	+	</figure>
103	+
104	+	### Mit Manifest
105	+
106	+	Ebenfalls bei 144 DPI (150%). Dieses Mal enthält die Anwendung ein Manifest, aber sie enthält keinen Code, um mit der Skalierung umzugehen. Die Elemente werden nicht skaliert, die Schrift schon (Windows macht das automatisch), also wird der Text abgeschnitten.
107	+
108	+	<figure>
109	+	<img src="cpicksniff_nohighdpi.png" title="cpicksniff_nohighdpi.png" />
110	+	<figcaption>cpicksniff_nohighdpi.png</figcaption>
111	+	</figure>
112	+
113	+	### High DPI
114	+
115	+	Zuletzt mit Manifest und einem Skalierungshandler, die Anwendung ist in High DPI.
116	+
117	+	<figure>
118	+	<img src="cpicksniff_highdpi.png" title="cpicksniff_highdpi.png" />
119	+	<figcaption>cpicksniff_highdpi.png</figcaption>
120	+	</figure>
121	+
122	+	## Hochauflösender Text in Lazarus
123	+
124	+	Mit Lazarus erzeugen Sie eine Anwendung für hochauflösende Schriftgrößen unter Windows 7 mit den beiden folgenden Schritten.
125	+
126	+	### SCHRITT 1 - Deklarieren Sie High DPI Awareness
127	+
128	+	Dazu brauchen Sie eine Manifest-Datei die diese Deklaration enthält. Mit Lazarus 0.9.30 erreichen Sie dies mit Projekt \> Projekteinstellungen \> dann wählen Sie die Optionen "Themen mit Manifest-Datei einschalten (nur in Windows)" und "dpi-abhängige Anwendung (für Vista +)".
129	+
130	+	### SCHRITT 2 - Skalieren Sie die Formulare und Steuerelemente
131	+
132	+	Dazu rufen Sie die folgende Prozedur 'ScaleDPI' im Ereignis 'OnCreate' eines jeden Formulars aus Ihrem Projekt auf.
133	+
134	+	Kopieren Sie zuerst den nachfolgenden Code und speichern Sie ihn in einer Textdatei namens "uscaledpi.pas":
135	+
136	+	``` pascal
137	+	unit uscaledpi;
138	+
139	+	{$mode objfpc}{$H+}
140	+
141	+	interface
142	+
143	+	uses
144	+	Forms, Graphics, Controls;
145	+
146	+	procedure HighDPI(FromDPI: Integer);
147	+	procedure ScaleDPI(Control: TControl; FromDPI: Integer);
148	+
149	+	implementation
150	+
151	+	procedure HighDPI(FromDPI: Integer);
152	+	var
153	+	i: Integer;
154	+	begin
155	+	for i:=0 to Screen.FormCount-1 do
156	+	ScaleDPI(Screen.Forms[i],FromDPI);
157	+	end;
158	+
159	+	procedure ScaleDPI(Control: TControl; FromDPI: Integer);
160	+	var
161	+	n: Integer;
162	+	WinControl: TWinControl;
163	+	begin
164	+	if Screen.PixelsPerInch = FromDPI then exit;
165	+
166	+	with Control do begin
167	+	Left:=ScaleX(Left,FromDPI);
168	+	Top:=ScaleY(Top,FromDPI);
169	+	Width:=ScaleX(Width,FromDPI);
170	+	Height:=ScaleY(Height,FromDPI);
171	+	Font.Height := ScaleY(Font.GetTextHeight('Hg'),FromDPI);
172	+	end;
173	+
174	+	if Control is TWinControl then begin
175	+	WinControl:=TWinControl(Control);
176	+	if WinControl.ControlCount > 0 then begin
177	+	for n:=0 to WinControl.ControlCount-1 do begin
178	+	if WinControl.Controls[n] is TControl then begin
179	+	ScaleDPI(WinControl.Controls[n],FromDPI);
180	+	end;
181	+	end;
182	+	end;
183	+	end;
184	+	end;
185	+
186	+	end.
187	+	```
188	+
189	+	Kopieren Sie diese Datei "uscaledpi.pas" in den Hauptordner Ihres Projekts:
190	+
191	+	` MyProject\uscaledpi.pas`\
192	+	` `
193	+
194	+	Fügen Sie im Abschnitt "uses" von Ihrem Projekt den Ausdruck "uScaleDPI" hinzu:
195	+
196	+	``` pascal
197	+	unit form1;
198	+
199	+	{$mode objfpc}{$H+}
200	+
201	+	interface
202	+
203	+	uses
204	+	Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs,
205	+	uScaleDPI; // Dies enthält die Prozedur 'ScaleDPI'
206	+	```
207	+
208	+	Das OnCreate-Ereignis jedes Formulars ruft die Prozedur so auf:
209	+
210	+	``` pascal
211	+	procedure TForm1.FormCreate(Sender: TObject);
212	+	begin
213	+	ScaleDPI(Self,96); // 96 ist der DPI-Wert beim Entwurf des Formulars
214	+	end;
215	+	```
216	+
217	+	### Skalieren Sie alle Formulare
218	+
219	+	Sie können den Schritt 2 abändern, um alle Formulare zu skalieren.
220	+
221	+	Dazu öffnen Sie den Quelltext Ihres Projektes (typischerweise die Datei Project1.lpr) und fügen 'uScaleDPI' im Abschnitt 'uses' hinzu.
222	+
223	+	Dann rufen Sie die Prozedur HighDPI nach dem Code der die Formulare initialisiert auf:
224	+
225	+	``` pascal
226	+	begin
227	+	RequireDerivedFormResource := True;
228	+	Application.Initialize;
229	+	Application.CreateForm(TForm1, Form1);
230	+	Application.CreateForm(TForm2, Form2);
231	+	Application.CreateForm(TForm3, Form3);
232	+	HighDPI(96); // 96 ist der DPI-Wert beim Entwurf der Formulare Form1, Form2 & Form3
233	+	Application.Run;
234	+	end.
235	+	```
236	+
237	+	Das Ergebnis sieht so aus:
238	+
239	+	``` pascal
240	+	program Project1;
241	+
242	+	{$mode objfpc}{$H+}
243	+
244	+	uses
245	+	{$IFDEF UNIX}{$IFDEF UseCThreads}
246	+	cthreads,
247	+	{$ENDIF}{$ENDIF}
248	+	Interfaces, Forms,
249	+	Unit1, Unit2, Unit3,
250	+	uScaleDPI;
251	+
252	+	{$R *.res}
253	+
254	+	begin
255	+	RequireDerivedFormResource := True;
256	+	Application.Initialize;
257	+	Application.CreateForm(TForm1, Form1);
258	+	Application.CreateForm(TForm2, Form2);
259	+	Application.CreateForm(TForm3, Form3);
260	+	HighDPI(96);
261	+	Application.Run;
262	+	end.
263	+	```
264	+
265	+	### Fortgeschrittenes
266	+
267	+	Einige Steuerelemente haben mehr Eigenschaften oder abweichende Eigenschaftsnamen wie TToolBar-Buttons (ButtonHeight / ButtonWidth anstelle von Width / Height). Ebenso kann sich das Verhalten unter verschiedenen Betriebssystemen ändern, wenn Sie festgelegte Schriftgrößen verwenden.
268	+
269	+	Sie können die Prozedur 'ScaleDPI' anpassen, sodass der Code alle Steuerelemente in der von Ihnen gewünschten Weise skaliert.
270	+
271	+	Dies ist die in [[LazPaint]] verwendete Unit uscaledpi. Sie ist beim Skalieren von ToolBars und ToolBox hilfreich. LazPaint verwendet auch fixe Schriftgrößen für eine einheitliche Darstellung unter verschiedenen Betriebssystemen.
272	+
273	+	``` pascal
274	+	unit uscaledpi;
275	+
276	+	{$mode objfpc}{$H+}
277	+
278	+	interface
279	+
280	+	uses
281	+	Forms, Graphics, Controls, ComCtrls;
282	+
283	+	procedure HighDPI(FromDPI: Integer);
284	+	procedure ScaleDPI(Control: TControl; FromDPI: Integer);
285	+	procedure ScaleImageList(ImgList: TImageList; FromDPI: Integer);
286	+
287	+	implementation
288	+
289	+	uses BGRABitmap, BGRABitmapTypes;
290	+
291	+	procedure HighDPI(FromDPI: Integer);
292	+	var
293	+	i: Integer;
294	+	begin
295	+	for i:=0 to Screen.FormCount-1 do begin
296	+	ScaleDPI(Screen.Forms[i],FromDPI);
297	+	end;
298	+	end;
299	+
300	+	procedure ScaleImageList(ImgList: TImageList; FromDPI: Integer);
301	+	var
302	+	TempBmp: TBitmap;
303	+	TempBGRA: array of TBGRABitmap;
304	+	NewWidth,NewHeight: integer;
305	+	i: Integer;
306	+
307	+	begin
308	+	if Screen.PixelsPerInch = FromDPI then exit;
309	+
310	+	NewWidth := ScaleX(ImgList.Width,FromDPI);
311	+	NewHeight := ScaleY(ImgList.Height,FromDPI);
312	+
313	+	setlength(TempBGRA, ImgList.Count);
314	+	TempBmp := TBitmap.Create;
315	+	for i := 0 to ImgList.Count-1 do
316	+	begin
317	+	ImgList.GetBitmap(i,TempBmp);
318	+	TempBGRA[i] := TBGRABitmap.Create(TempBmp);
319	+	TempBGRA[i].ResampleFilter := rfBestQuality;
320	+	if (TempBGRA[i].width=0) or (TempBGRA[i].height=0) then continue;
321	+	while (TempBGRA[i].Width < NewWidth) or (TempBGRA[i].Height < NewHeight) do
322	+	BGRAReplace(TempBGRA[i], TempBGRA[i].FilterSmartZoom3(moLowSmooth));
323	+	BGRAReplace(TempBGRA[i], TempBGRA[i].Resample(NewWidth,NewHeight));
324	+	end;
325	+	TempBmp.Free;
326	+
327	+	ImgList.Clear;
328	+	ImgList.Width:= NewWidth;
329	+	ImgList.Height:= NewHeight;
330	+
331	+	for i := 0 to high(TempBGRA) do
332	+	begin
333	+	ImgList.Add(TempBGRA[i].Bitmap,nil);
334	+	TempBGRA[i].Free;
335	+	end;
336	+	end;
337	+
338	+	procedure ScaleDPI(Control: TControl; FromDPI: Integer);
339	+	var
340	+	n: Integer;
341	+	WinControl: TWinControl;
342	+	ToolBarControl: TToolBar;
343	+	begin
344	+	if Screen.PixelsPerInch = FromDPI then exit;
345	+
346	+	with Control do begin
347	+	Left:=ScaleX(Left,FromDPI);
348	+	Top:=ScaleY(Top,FromDPI);
349	+	Width:=ScaleX(Width,FromDPI);
350	+	Height:=ScaleY(Height,FromDPI);
351	+	Font.Height := ScaleY(Font.GetTextHeight('Hg'),FromDPI);
352	+	end;
353	+
354	+	if Control is TToolBar then begin
355	+	ToolBarControl:=TToolBar(Control);
356	+	with ToolBarControl do begin
357	+	ButtonWidth:=ScaleX(ButtonWidth,FromDPI);
358	+	ButtonHeight:=ScaleY(ButtonHeight,FromDPI);
359	+	end;
360	+	end;
361	+
362	+	if Control is TWinControl then begin
363	+	WinControl:=TWinControl(Control);
364	+	if WinControl.ControlCount > 0 then begin
365	+	for n:=0 to WinControl.ControlCount-1 do begin
366	+	if WinControl.Controls[n] is TControl then begin
367	+	ScaleDPI(WinControl.Controls[n],FromDPI);
368	+	end;
369	+	end;
370	+	end;
371	+	end;
372	+	end;
373	+
374	+	end.
375	+	```
376	+
377	+	## Abschließende Bemerkungen
378	+
379	+	Das Entwickeln von Anwendungen, die die DPI-Einstellungen und Themen berücksichtigen, umfasst zwei Schritte:
380	+
381	+	- Legen Sie eine fixe Schriftgröße fest zum Zeitpunkt der Entwickung (Nützlich für cross-platform Anwendungen, aber unnötig wenn nur Windows als Zielsystem)
382	+	- Skalieren Sie die Komponenten zur Laufzeit
383	+	- Passen Sie den ScaleDPI-Code an Ihre Bedürfnisse an
384	+
385	+	Anmerkung:
386	+
387	+	Siehe die Diskussionsseite für weitere Informationen: Talk:High_DPI.
388	+
389	+	Wir verwenden nicht ScaleBy & ScaleControls:
390	+
391	+	``` pascal
392	+	Self.ScaleBy(Screen.PixelsPerInch,96);
393	+	```
394	+
395	+	Dies skaliert die Schrift, ist aber unter Windows überflüssig, weil das Betriebssystem die Schrift selbst ändert. Könnte nützlich sein, wenn Sie eine fixierte Schriftgröße verwenden.
396	+
397	+	``` pascal
398	+	Self.ScaleControls(Screen.PixelsPerInch,96);
399	+	```
400	+
401	+	Dies skaliert nicht die Breite / Höhe des Formulars. Könnte nützlich sein, wenn Sie diese selbst skalieren.
402	+
403	+	## Externe Links
404	+
405	+	- \[<http://msdn.microsoft.com/en-us/library/dd464646(v=VS.85>).aspx High DPI (Windows)\] MSDN article about High DPI
406	+	- [[Windows Icon]] How to create icons that work with High DPI.
407	+
408	+	---
409	+	From the Free Pascal wiki, page "High DPI/de", as it stood on 2020-02-17 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history