web-dev-qa-db-fra.com

Comment configurer une application pour qu'elle s'exécute correctement sur une machine avec un paramètre DPI élevé (par exemple 150%)?

J'ai créé une simple application Winforms en C #. Lorsque j'exécute l'application sur une machine avec des paramètres DPI élevés (par exemple 150%), l'application est mise à l'échelle. Jusqu'ici tout va bien! Mais au lieu de rendre les polices avec une taille de police plus élevée, tous les textes sont également agrandis. Cela conduit bien sûr à un texte très flou (sur tous les contrôles comme les boutons, etc.).

Les fenêtres ne devraient-elles pas prendre en charge le rendu des textes correctement? Par exemple, la barre de titre de mon application est rendue claire et nette.

c#winformsfontsdpidpi-aware
84
Boris

Une fois que vous avez dépassé 100% (ou 125% avec la case à cocher "Mise à l'échelle DPI de style XP" cochée), Windows prend en charge par défaut la mise à l'échelle de votre interface utilisateur. Pour ce faire, votre application affiche sa sortie sur un bitmap et dessine ce bitmap à l'écran. Le redimensionnement de ce bitmap rend inévitablement le texte flou. Fonctionnalité appelée "virtualisation DPI", elle conserve les anciens programmes utilisables sur les moniteurs haute résolution.

Vous devez explicitement lui faire savoir que vous pouvez gérer des paramètres DPI plus élevés en ajoutant le <dpiAware> élément de votre manifeste. La page MSDN est ici mais elle n'est pas complète car elle omet les paramètres UAC. Projet + Ajouter un nouvel élément, choisissez "Fichier manifeste d'application". Modifiez le texte du manifeste ou copiez/collez ceci:

<?xml version="1.0" encoding="utf-8"?>
<Assembly xmlns="urn:schemas-Microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-Microsoft-com:asm.v3" >
    <assemblyIdentity version="1.0.0.0" name="MyApplication.app"/>
    <trustInfo xmlns="urn:schemas-Microsoft-com:asm.v2">
        <security>
            <requestedPrivileges xmlns="urn:schemas-Microsoft-com:asm.v3">
                <requestedExecutionLevel level="asInvoker" uiAccess="false" />
            </requestedPrivileges>
        </security>
    </trustInfo>
    <asmv3:application>
        <asmv3:windowsSettings xmlns="http://schemas.Microsoft.com/SMI/2005/WindowsSettings">
            <dpiAware>true</dpiAware>
        </asmv3:windowsSettings>
    </asmv3:application>
</Assembly>

Vous pouvez également épingler SetProcessDPIAware () dans votre méthode Main (), nécessaire par exemple si vous déployez avec ClickOnce:

    [STAThread]
    static void Main() {
        if (Environment.OSVersion.Version.Major >= 6) SetProcessDPIAware();
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1());             // Edit as needed
    }

    [System.Runtime.InteropServices.DllImport("user32.dll")]
    private static extern bool SetProcessDPIAware();

MISE À JOUR, ce besoin commun est enfin un peu plus facile si vous utilisez VS2015 Update 1 ou supérieur. Le manifeste ajouté contient déjà la directive pertinente, supprimez simplement les commentaires.

Mot-clé de recherche pour retrouver cet article: dpiAware

118
Hans Passant

Les applications peuvent être développées en deux modes différents.

La première consiste à déclarer que notre application n'est pas compatible DPI (ne rien déclarer par défaut). Dans ce cas, le système d'exploitation rendra notre application sous le 96 DPI attendu et fera ensuite la mise à l'échelle bitmap dont nous avons discuté auparavant. Le résultat sera une application d'aspect flou, mais avec une mise en page correcte.

La deuxième option consiste à déclarer l'application compatible DPI. Dans ce cas, le système d'exploitation ne fera aucune mise à l'échelle et laissera votre application effectuer le rendu en fonction du DPI d'origine de l'écran. Dans le cas d'un environnement par moniteur DPI, votre application sera rendue avec le DPI le plus élevé de tous les écrans, puis cette image bitmap sera réduite à la taille appropriée pour chaque moniteur. La mise à l'échelle entraîne une meilleure expérience de visualisation que la mise à l'échelle, mais vous remarquerez peut-être encore un peu de flou.

Si vous souhaitez éviter cela, vous devez déclarer votre application comme compatible avec le moniteur DPI. Ensuite, vous devez détecter le moment où votre application est déplacée sur différents moniteurs et effectuer le rendu en fonction du DPI de celui en cours.

La déclaration de la reconnaissance DPI est effectuée dans un fichier manifeste.

référez-vous au lien suivant stackoverflow

15
shanthi_karthika

Aucune de ces suggestions n'a fonctionné pour moi, mais quelque chose s'est produit après avoir supprimé le Form.Font = new ... du Form.Design.cs, le formulaire a commencé à se redimensionner correctement, cela fonctionne si la police est définie dans le constructeur ou pas du tout. Pourquoi? quelqu'un d'autre pourra peut-être l'expliquer, je peux juste parler du changement que j'ai fait et m'a pris quelques minutes pour comprendre que c'était la cause première du formulaire sur lequel je travaillais. J'espère que ça aide.

3
Vasco Bonilla

En utilisant .NET Framework 4.7 et Windows 10 Creators Update ou plus récent, vous devez effectuer les opérations suivantes pour configurer une prise en charge PPP élevée pour votre application Windows Form:

Déclarez la compatibilité avec Windows 10.

Pour ce faire, ajoutez ce qui suit à votre fichier manifest:

<compatibility xmlns="urn:schemas-Microsoft.com:compatibility.v1">
  <application>
    <!-- Windows 10 compatibility -->
    <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
  </application>
</compatibility>

Activez la reconnaissance DPI par moniteur dans le app.config fichier.

Windows Forms introduit un nouvel élément System.Windows.Forms.ApplicationConfigurationSection pour prendre en charge les nouvelles fonctionnalités et personnalisations ajoutées à partir de .NET Framework 4.7. Pour profiter des nouvelles fonctionnalités qui prennent en charge un DPI élevé, ajoutez ce qui suit à votre fichier de configuration d'application.

<System.Windows.Forms.ApplicationConfigurationSection>
  <add key="DpiAwareness" value="PerMonitorV2" />
</System.Windows.Forms.ApplicationConfigurationSection>

Important

Dans les versions précédentes de .NET Framework, vous utilisiez le manifeste pour ajouter une prise en charge PPP élevée. Cette approche n'est plus recommandée, car elle remplace les paramètres définis dans le fichier app.config.

Appelez la méthode statique EnableVisualStyles.

Cela devrait être le premier appel de méthode dans votre point d'entrée d'application. Par exemple:

static void Main()
{
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    Application.Run(new Form2());   
}

L'avantage de ceci est la prise en charge des scénarios DPI dynamiques dans lesquels l'utilisateur modifie le DPI ou le facteur d'échelle après le lancement d'une application Windows Forms.

Source: Prise en charge haute résolution dans Windows Forms

1
Wollmich