Comment garantir que votre application s’affiche correctement sur les affichages haute résolution

Bien que DirectWrite résout de nombreux problèmes de haute résolution pour vous, vous devez suivre deux étapes pour vous assurer que votre application fonctionne correctement sur les affichages haute résolution :

Étape 1 : utiliser la résolution système en cas de création de fenêtres

Cette opération peut être effectuée à l’aide de Direct2D ou de GDI.

Direct2D

L’interface ID2D1Factory fournit la méthode GetDesktopDpi pour récupérer la résolution du système. Il fournit les dimensions horizontales et verticales de l’affichage en points par pouce (DPI). Pour utiliser ces valeurs pour définir la largeur d’une fenêtre, utilisez la formule suivante :

<PPP > * horizontal < largeur, en pixels>/<PPP horizontal par défaut>

... où PPP horizontal est la valeur récupérée par GetDpi et la valeur PPP horizontale par défaut est 96. La formule est similaire pour la taille verticale :

<dpi > * vertical < hauteur, en pixels>/<dpi vertical par défaut>

... où la valeur PPP verticale est la valeur récupérée par la méthode GetDesktopDpi et la valeur ppp verticale par défaut est 96.

Le code suivant utilise la méthode GetDesktopDpi pour créer une fenêtre 640 x 480, mise à l’échelle en dpi système. (Dans le code suivant, m _ spD2DFactory est un pointeur intelligent vers une instance ID2D1Factory .)

        // Because the CreateWindow function takes its size in pixels,
        // obtain the system DPI and use it to scale the window size.
        FLOAT dpiX, dpiY;

        // The factory returns the current system DPI. This is also the value it will use
        // to create its own windows.
        m_pDirect2dFactory->GetDesktopDpi(&dpiX, &dpiY);


        // Create the window.
        m_hwnd = CreateWindow(
            L"D2DDemoApp",
            L"Direct2D Demo App",
            WS_OVERLAPPEDWINDOW,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            static_cast<UINT>(ceil(640.f * dpiX / 96.f)),
            static_cast<UINT>(ceil(480.f * dpiY / 96.f)),
            NULL,
            NULL,
            HINST_THISCOMPONENT,
            this
            );

GDI

GDI fournit la fonction GetDeviceCaps pour la récupération des informations de l’appareil. Vous pouvez récupérer les informations PPP en passant les valeurs d’index LOGPIXELSX et LOGPIXELSY . La formule permettant de déterminer la taille horizontale et verticale d’une fenêtre est la même que celle de l’exemple Direct2D ci-dessus.

Le code suivant utilise la fonction GetDeviceCaps pour créer une fenêtre 640 x 480, mise à l’échelle vers la résolution système.

FLOAT dpiX, dpiY;

HDC screen = GetDC(0);
dpiX = static_cast<FLOAT>(GetDeviceCaps(screen, LOGPIXELSX));
dpiY = static_cast<FLOAT>(GetDeviceCaps(screen, LOGPIXELSY));
ReleaseDC(0, screen);

hWnd = CreateWindow(
         TEXT("DirectWriteApp"),
         TEXT("DirectWrite Demo App"),
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT,
         CW_USEDEFAULT,
         static_cast<INT>(dpiX * 640.f / 96.f),
         static_cast<INT>(dpiY * 480.f / 96.f),
         NULL,
         NULL,
         hInstance,
         NULL
         );

Étape 2 : déclarer que l’application est DPI-Aware

Quand une application se déclare être prise en charge DPI, il s’agit d’une instruction spécifiant que l’application se comporte correctement aux paramètres ppp jusqu’à 200 ppp. Dans Windows Vista et Windows 7, lorsque la virtualisation DPI est activée, les applications qui ne prennent pas en charge la résolution sont mises à l’échelle, et les applications reçoivent des données virtualisées à partir des API système, telles que la fonction GetSystemMetric . Pour déclarer que votre application prend en charge DPI, procédez comme suit.

  1. Créez un fichier appelé DeclareDPIAware. manifest.

  2. Copiez le code XML suivant dans le fichier et enregistrez-le :

    <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3" >
      <asmv3:application>
        <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
          <dpiAware>true</dpiAware>
        </asmv3:windowsSettings>
      </asmv3:application>
    </assembly>
    
  3. Dans le fichier. vcproj du projet, ajoutez l’entrée suivante dans chaque élément de configuration sous VisualStudioProject/configurations :

    <Tool
        Name="VCManifestTool"
        AdditionalManifestFiles="DeclareDPIAware.manifest"
    />
    

Direct2D et haute résolution