Hohe DPI

Displays mit hoher DPI – auch als Retina-Displays bekannt – sind Displays mit einer im Verhältnis zu ihrer physischen Größe (mm) hohen Auflösung (Pixel), was zu einer hohen Pixeldichte oder einer hohen Anzahl von Punkten pro Zoll (DPI) führt. Die erhöhte Auflösung dient dazu, detailliertere Inhalte auf dem Bildschirm darzustellen (glatterer Text, detailliertere Symbole), und nicht dazu, mehr Inhalte anzuzeigen (mehr Fenster, größere Fenstergrößen).

Qt unterstützt High-DPI-Displays auf allen Plattformen und bietet eine einheitliche API, die Plattformunterschiede abstrahiert. Qt berücksichtigt automatisch die Bildschirmauflösung bei der Verwendung von übergeordneten APIs wie Qt Widgets und Qt Quick, und Anwendungen müssen lediglich hochauflösende Elemente wie Bilder und Symbole bereitstellen. Änderungen in den Benutzereinstellungen der Plattform werden automatisch übernommen.

Grafikdarstellungen auf niedrigerer Ebene (wie z. B. OpenGL-Code) müssen High-DPI-fähig sein, können jedoch plattformübergreifende Qt-APIs nutzen, um die Bildschirmauflösungen der jeweiligen Plattform zu ermitteln.

Konzeptionelles Modell

Qt verwendet ein Modell, bei dem das Koordinatensystem der Anwendung unabhängig von der Auflösung des Anzeigegeräts ist. Die Anwendung arbeitet mit geräteunabhängigen Pixeln, die dann über einen Skalierungsfaktor, der als Gerätepixelverhältnis bezeichnet wird, auf die physischen Pixel des Displays abgebildet werden. Der Skalierungsfaktor wird als Gleitkommazahl ausgedrückt, zum Beispiel 1.0 oder 2.0, oder informell als 1x und 2x.

Wenn man beispielsweise ein „ QWindow “ oder „ QWidget “ erstellt und dessen Größe auf 200×200 festlegt, deckt dies auf einem Display mit Standarddichte (mit einem Gerätepixelverhältnis von 1,0) 200×200 Displaypixel ab, auf einem Display mit hoher Dichte (mit einem Gerätepixelverhältnis von 2,0) jedoch 400x400 Pixel ab.

Dieses Modell gilt für die meisten Einheiten in den übergeordneten „ Qt GUI “, Widgets und Quick-APIs, einschließlich der Geometrie von Widgets und Elementen, der Ereignisgeometrie, der Desktop-, Fenster- und Bildschirmgeometrie sowie der Animationsgeschwindigkeiten.

Zeichnen

Qt nutzt automatisch die erhöhte Dichte eines Displays mit hoher DPI-Auflösung, wenn Zeichen-APIs wie „ QPainter “ verwendet werden oder wenn Grafikprimitive oder Text in „ Qt Quick “ gerendert werden.

Dadurch kann die Anwendung in einem einzigen einheitlichen Koordinatensystem arbeiten, ohne die möglichen Bildschirmauflösungen berücksichtigen zu müssen, auf denen die Anwendung ausgeführt wird.

Bei der Verwendung von Zeichnungs-APIs auf niedrigerer Ebene, beispielsweise OpenGL, muss die Anwendung jedoch das Gerätepixelverhältnis des Displays berücksichtigen. Dies ist sowohl pro Fenster verfügbar, als „ QWindow::devicePixelRatio()“ (Verfolgung des Gerätepixelverhältnisses des Fensters beim Verschieben zwischen Displays), als auch pro Display, als „ QScreen::devicePixelRatio()“.

Bildpuffer wie QImage und QPixmap repräsentieren die Rohpixel und arbeiten daher nicht in dem zuvor beschriebenen geräteunabhängigen Koordinatensystem. Ein „ QImage “ mit einer Größe von 400x400, mit einem Gerätepixelverhältnis von 2,0 passt auf einem Display mit hoher Dichte (2x) in einen 200x200- QWindow, oder wird beim Zeichnen automatisch auf 200x200 herunterskaliert, wenn ein Display mit Standarddichte (1x) als Ziel dient. Weitere Details finden Sie unter Drawing High Resolution Versions of Pixmaps and Images.

Bildressourcen

Um die Vorteile der höheren Pixeldichte von High-DPI-Displays zu nutzen, sollte die Anwendung auch High-DPI-Versionen statischer Bildressourcen enthalten. Dies wird durch die Verwendung einer speziellen Namenskonvention für die hochauflösenden Assets erreicht, zum Beispiel logo@2x.png, und durch das Laden sowohl des Bildes mit normaler Dichte als auch des hochauflösenden Bildes in ein QIcon. Qt wählt zur Laufzeit automatisch die beste Darstellung für das Ziel-Display aus. Weitere Details finden Sie unter High DPI Icons.

Geräteunabhängige Bildschirmgeometrie

Qt-Anwendungen arbeiten im Allgemeinen mit geräteunabhängigen Pixeln. Dies umfasst auch die der Anwendung gemeldeten Fenster- und Bildschirmgeometrien.

Das bedeutet, dass ` QScreen::geometry()` möglicherweise nicht die physische Pixelanzahl des Bildschirms oder die vom Betriebssystem gemeldete Pixelgröße zurückgibt. Dies hat Auswirkungen auf die Geometrie des virtuellen Desktops:

Moderne Desktop-Betriebssysteme erstellen in der Regel ein gemeinsames Koordinatensystem für alle angeschlossenen Bildschirme und ermöglichen es dem Benutzer, die Bildschirme entsprechend seiner physischen Bildschirmkonfiguration zu positionieren, meist über einen Konfigurationsdialog. Wenn diese Positionierung in einem Koordinatensystem erfolgt, das den geräteunabhängigen Pixeln von Qt entspricht (wie unter macOS), stimmt die Geometrie von ` QScreen ` mit dem nativen Bildschirmlayout überein. Erfolgt die Positionierung hingegen in physischen Bildschirmpixeln (wie unter Windows), kann die Behandlung der Bildschirmgeometrie durch Qt zu Lücken in der Geometrie des virtuellen Desktops führen, die von keinem Bildschirm genutzt werden.

Konkret skaliert Qt die Bildschirmgröße (was bei positiven Skalierungsfaktoren zu einem „kleineren“ Bildschirm führt), ändert jedoch nicht die Bildschirmposition. Dies führt zu einer virtuellen Desktop-Geometrie vom Typ „Bildschirminseln“.

Anwendungscode sollte nicht davon ausgehen, dass eine Position, die unmittelbar an einen Bildschirm angrenzt und außerhalb dieses Bildschirms liegt, eine gültige Position auf dem benachbarten Bildschirm ist. Rufen Sie stattdessen die Bildschirmliste mit ` QGuiApplication::screens()` ab und nutzen Sie diese Liste, um die verfügbare Bildschirmgeometrie zu ermitteln.

Konfiguration

Möglicherweise möchten Sie die DPI- oder Skalierungseinstellungen an die Bildschirmhardware anpassen oder den Betrachtungsabstand und persönliche Vorlieben berücksichtigen. Diese Anpassungen sollten über die nativen Anzeigeeinstellungen der Plattform vorgenommen werden, damit alle Anwendungen dieselben DPI- oder Skalierungsfaktorwerte verwenden. Qt bietet keine Funktionen für Endbenutzer, um das Verhalten der Qt-Unterstützung für hohe DPI-Werte zu konfigurieren.

Das Betriebssystem kann den Skalierungsfaktor entweder als Faktor (1,5), als Prozentsatz (150 %) oder als Punkte pro Zoll (144 DPI) darstellen. Qt rechnet diese Werte in das von der Anwendung erkannte Gerätepixelverhältnis um. Im letzteren Fall geht Qt von einem „Basis“-DPI aus – beispielsweise 96 unter X11 – und berechnet das resultierende Gerätepixelverhältnis entsprechend.

Für optimale Ergebnisse werden ganzzahlige Skalierungsfaktoren (z. B. 1,0 oder 2,0) bevorzugt. Das „Abrunden“ des Skalierungsfaktors auf 25-Prozent-Schritte kann ebenfalls zu guten Ergebnissen führen. Die Einstellung des Skalierungsfaktors oder der DPI auf den exakten physikalischen DPI-Wert des Displays führt aufgrund der damit verbundenen fraktionierten Skalierung möglicherweise nicht zu guten visuellen Ergebnissen. Wenn die Anwendung in diesem Szenario unter visuellen Artefakten leidet, kann sie mit ` QGuiApplication::setHighDpiScaleFactorRoundingPolicy()` die von ihr wahrgenommenen Skalierungsfaktoren begrenzen.

Plattformdetails

Die folgende Tabelle beschreibt, wie High-DPI auf verschiedenen Plattformen konfiguriert wird:

Konfiguration von X11

Die von Qt benötigte Konfigurationsangabe ist der logische DPI-Wert pro Bildschirm. Derzeit bietet X11 entweder einen globalen logischen DPI-Wert oder einen physikalischen DPI-Wert pro Bildschirm. Keiner dieser Werte entspricht genau den Anforderungen von Qt, was die DPI-Konfiguration unter X11 komplizierter machen kann als auf anderen Plattformen.

Desktop-Umgebungen wie Ubuntu und Kubuntu implementieren Workarounds für das Fehlen der logischen DPI und bieten eine einfach konfigurierbare Unterstützung für hohe DPI-Werte. Wenn Sie die X11-DPI-Einstellungen stattdessen manuell konfigurieren möchten, beschreibt dieser Abschnitt, welche X11-Einstellungen Qt ausliest.

Bei einigen X11-Konfigurationsabläufen wird die gemeldete physische Größe des Bildschirms überschrieben, damit die DPI-Berechnungen einen bestimmten DPI-Wert ergeben. Qt unterstützt diesen Ablauf, allerdings muss dies, wie unten beschrieben, aktiviert werden.

Die genaue Konfigurationspriorität ist wie folgt, wobei Qt die erste verfügbare Option verwendet.

Verwendung der physikalischen DPI unter X11

Um Qt zu zwingen, bedingungslos die physikalische RandR-DPI anstelle der logischen DPI zu verwenden, setzen Sie „ QT_USE_PHYSICAL_DPI=1 “. Qt liest dann die Felder „ mwidth “ und „ mheight “ der Struktur „ xcb_randr_screen_change_notify_event_t “ aus und rundet den resultierenden DPI-Wert auf eine ganze Zahl.

Dies ist nützlich, wenn der logische DPI-Wert nicht verfügbar ist und der physikalische DPI-Wert des Bildschirms bekanntermaßen korrekt ist. Siehe auch „Referenz zu Umgebungsvariablen“.

Konfiguration unter Windows

Qt verwendet automatisch die Windows-Einstellungen zur Bildschirmskalierung; es sind keine speziellen Einstellungen erforderlich. Ist ein Bildschirm beispielsweise auf eine Skalierung von 175 % konfiguriert, erkennen Qt-Anwendungen auf diesem Bildschirm ein Gerätepixelverhältnis von 1,75.

Windows definiert mehrere DPI-Erkennungsstufen, die Anwendungen einstellen können, um High-DPI-Funktionen zu aktivieren. Qt 6 ist standardmäßig auf „Per-Monitor DPI Aware V2“ eingestellt. Wenn Sie Code einbinden, der von einem einzigen globalen DPI-Wert ausgeht, sollten Sie möglicherweise eine andere Erkennungsstufe festlegen. Fügen Sie dazu Folgendes in die Datei „ qt.conf “ ein:

[Platforms]
WindowsArguments = dpiawareness=0,1,2

Testen

Bei der Entwicklung oder dem Debuggen der High-DPI-Unterstützung ist es oft unpraktisch, sich auf bestimmte Hardware zu verlassen. Qt stellt eine Umgebungsvariable zur Simulation verschiedener Skalierungsfaktoren sowie eine Testanwendung bereit, mit der überprüft werden kann, wie Qt die aktuelle Bildschirmkonfiguration interpretiert.

QT_SCALE_FACTOR

Setzen Sie die Umgebungsvariable ` QT_SCALE_FACTOR `, um einen globalen Skalierungsfaktor für die Anwendung festzulegen.

Beispiel:

QT_SCALE_FACTOR=2 ./myapp

Dadurch wird die gesamte Anwendungsgeometrie (einschließlich des Gerätepixelverhältnisses) um den angegebenen Faktor skaliert, was das Testen der High-DPI-Unterstützung unabhängig von der verfügbaren Hardware ermöglicht.

Der festgelegte Skalierungsfaktor wird von Qt XML unverändert verwendet und wird von ` rounding policy` nicht beeinflusst.

Das effektive Gerätepixelverhältnis, wie es von ` QWindow::devicePixelRatio()` zurückgegeben wird, ist das Produkt aus dem festgelegten Skalierungsfaktor und dem nativen Gerätepixelverhältnis. Wenn Sie beispielsweise auf einem 2x-Wayland-Display ` QT_SCALE_FACTOR=2 ` festlegen, sieht die Anwendung ein Gerätepixelverhältnis von 4.

DprGadget-Testanwendung

Mit der DprGadget-Testanwendung können Sie die native Konfiguration überprüfen und sehen, wie Qt darauf reagiert:

DprGadget zeigt das Gerätepixelverhältnis des Fensters an, wie es von ` QWindow::devicePixelRatio()` gemeldet wird. Darüber hinaus zeigt es die native DPI und das Gerätepixelverhältnis des Bildschirms an, auf dem sich das Fenster befindet, wie sie von `QPlatformScreen::logicalDpi()` und `QPlatformScreen::devicePixelRatio()` gemeldet werden.

Die angezeigten Werte sollten bei Änderungen des Bildschirms und der DPI automatisch aktualisiert werden, und der Dialog sollte seine Größe beibehalten. Ist dies nicht der Fall, könnte es sich um einen Qt-Fehler handeln.

DprGadget ist Teil der manuellen Testsuite von Qt und unter qtbase/tests/manual/highdpi/dprgadget zu finden.

Referenz zu Umgebungsvariablen

In diesem Abschnitt sind die von Qt erkannten Umgebungsvariablen im Zusammenhang mit hoher DPI aufgeführt. In alphabetischer Reihenfolge:

Referenz zu Koordinatensystemen

Die folgenden Koordinatensysteme werden in den APIs von Qt verwendet. Der Großteil des Anwendungscodes arbeitet mit geräteunabhängigen Pixeln; die anderen Systeme sind in erster Linie für Low-Level-Grafik und Plattformintegration relevant: