Partager via

Mise à l’échelle automatique dans Windows Forms

  • Article

La mise à l’échelle automatique permet à un formulaire et à ses contrôles, conçus sur un ordinateur avec une certaine résolution d’affichage ou une police système, d’être affichés de manière appropriée sur un autre ordinateur avec une autre résolution d’affichage ou une police système différente. Il garantit que le formulaire et ses contrôles seront redimensionnés intelligemment pour être cohérents avec les fenêtres natives et d’autres applications sur les machines des utilisateurs et d’autres développeurs. La prise en charge du .NET Framework pour la mise à l’échelle automatique et les styles visuels permet aux applications .NET Framework de maintenir une apparence cohérente par rapport aux applications Windows natives sur l’ordinateur de chaque utilisateur.

Pour la plupart, la mise à l’échelle automatique fonctionne comme prévu dans .NET Framework version 2.0 et ultérieure. Toutefois, les modifications apportées au schéma de police peuvent être problématiques. Pour obtenir un exemple de résolution de ce problème, consultez Guide pratique pour répondre aux modifications apportées au schéma de police dans une application Windows Forms.

Besoin de mise à l’échelle automatique

Sans mise à l’échelle automatique, une application conçue pour une résolution d’affichage ou une police apparaît trop petite ou trop grande lorsque cette résolution ou cette police est modifiée. Par exemple, si l’application est conçue à l’aide de Tahoma 9 point comme base de référence, sans ajustement, elle apparaît trop petite si elle est exécutée sur un ordinateur où la police système est Tahoma 12 point. Les éléments de texte, tels que les titres, les menus, le contenu de la zone de texte, et ainsi de suite s’affichent plus petits que d’autres applications. En outre, la taille des éléments d’interface utilisateur qui contiennent du texte, tels que la barre de titre, les menus et de nombreux contrôles dépendent de la police utilisée. Dans cet exemple, ces éléments apparaissent également relativement plus petits.

Une situation analogue se produit lorsqu’une application est conçue pour une certaine résolution d’affichage. La résolution d’affichage la plus courante est de 96 points par pouce (PPP), qui est égale à 100% mise à l’échelle de l’affichage, mais la résolution supérieure affiche 125%, 150%, 200% (respectivement 120, 144 et 192 PPP) et versions ultérieures sont de plus en plus courantes. Sans ajustement, une application, en particulier une application basée sur des graphiques, conçue pour une résolution apparaît trop grande ou trop petite lors de l’exécution à une autre résolution.

La mise à l’échelle automatique cherche à réduire ces problèmes en redimensionnant automatiquement le formulaire et ses contrôles enfants en fonction de la taille de police relative ou de la résolution d’affichage. Le système d’exploitation Windows prend en charge la mise à l’échelle automatique des boîtes de dialogue à l’aide d’une unité relative de mesures appelée unités de dialogue. Une unité de dialogue est basée sur la police système et sa relation avec les pixels peut être déterminée via la fonction SDK Win32 GetDialogBaseUnits. Lorsqu’un utilisateur modifie le thème utilisé par Windows, toutes les boîtes de dialogue sont automatiquement ajustées en conséquence. En outre, .NET Framework prend en charge la mise à l’échelle automatique en fonction de la police système par défaut ou de la résolution d’affichage. Si vous le souhaitez, la mise à l’échelle automatique peut être désactivée dans une application.

Prise en charge initiale de la mise à l’échelle automatique

Les versions 1.0 et 1.1 du .NET Framework ont pris en charge la mise à l’échelle automatique d’une manière simple qui dépendait de la police par défaut Windows utilisée pour l’interface utilisateur, représentée par la valeur du Kit de développement logiciel (SDK) Win32 DEFAULT_GUI_FONT. Cette police est généralement modifiée uniquement lorsque la résolution d’affichage change. Le mécanisme suivant a été utilisé pour implémenter la mise à l’échelle automatique :

  1. Au moment du design, la propriété AutoScaleBaseSize (qui est désormais déconseillée) a été définie sur la hauteur et la largeur de la police système par défaut sur l’ordinateur du développeur.

  2. Lors de l’exécution, la police système par défaut de l’ordinateur de l’utilisateur a été utilisée pour initialiser la propriété Font de la classe Form.

  3. Avant d’afficher le formulaire, la méthode ApplyAutoScaling a été appelée pour mettre à l’échelle le formulaire. Cette méthode a calculé les tailles relatives de AutoScaleBaseSize et Font, puis a appelé la méthode Scale pour redimensionner le formulaire et ses enfants.

  4. La valeur de AutoScaleBaseSize a été mise à jour afin que les appels ultérieurs à ApplyAutoScaling ne redimensionnent pas progressivement le formulaire.

Bien que ce mécanisme soit suffisant à la plupart des fins, il a subi les limitations suivantes :

  • Étant donné que la propriété AutoScaleBaseSize représente la taille de police de référence en tant que valeurs entières, des erreurs d’arrondi se produisent, ce qui devient évident lorsqu’un formulaire est passé en revue à travers plusieurs résolutions.

  • La mise à l’échelle automatique a été implémentée uniquement dans la classe Form, et non dans la classe ContainerControl. Par conséquent, les contrôles utilisateur ne sont mis à l'échelle correctement que lorsque le contrôle utilisateur a été conçu à la même résolution que le formulaire et qu'il a été placé dans le formulaire lors de la conception.

  • Les formulaires et leurs contrôles enfants ne pouvaient être conçus simultanément que par plusieurs développeurs si leurs résolutions d’ordinateur étaient identiques. De même, cela a fait que l'héritage d'un formulaire dépend de la résolution associée au formulaire parent.

  • Il n’est pas compatible avec les gestionnaires de disposition plus récents introduits avec .NET Framework version 2.0, tels que FlowLayoutPanel et TableLayoutPanel.

  • Elle ne prenait pas en charge la mise à l’échelle directement basée sur la résolution d’affichage requise pour la compatibilité avec le .NET Compact Framework.

Bien que ce mécanisme soit conservé dans .NET Framework version 2.0 pour maintenir la compatibilité descendante, il a été remplacé par le mécanisme de mise à l’échelle plus robuste décrit ci-dessous. Par conséquent, les AutoScale, les ApplyAutoScaling, les AutoScaleBaseSizeet certaines surcharges de Scale sont marquées comme obsolètes.

Note

Vous pouvez supprimer en toute sécurité des références à ces membres lorsque vous mettez à niveau votre code hérité vers .NET Framework version 2.0.

Prise en charge actuelle de la mise à l’échelle automatique

.NET Framework version 2.0 démonte les limitations précédentes en introduisant les modifications suivantes à la mise à l’échelle automatique de Windows Forms :

  • La prise en charge de la mise à l'échelle a été déplacée vers la classe ContainerControl, de sorte que les formulaires, les contrôles composites natifs et les contrôles utilisateur bénéficient tous d'une mise à l'échelle uniforme. Les nouveaux membres AutoScaleFactor, AutoScaleDimensions, AutoScaleMode et PerformAutoScale ont été ajoutés.

  • La classe Control a également plusieurs nouveaux membres qui lui permettent de participer à la mise à l’échelle et de prendre en charge la mise à l’échelle mixte sur le même formulaire. Plus précisément, les membres Scale, ScaleChildrenet GetScaledBounds prennent en charge la mise à l’échelle.

  • La prise en charge de la mise à l’échelle basée sur la résolution d’écran a été ajoutée pour compléter la prise en charge de la police système, telle que définie par l’énumération AutoScaleMode. Ce mode est compatible avec la mise à l’échelle automatique prise en charge par le .NET Compact Framework, ce qui facilite la migration des applications.

  • La compatibilité avec les gestionnaires de disposition tels que FlowLayoutPanel et TableLayoutPanel a été ajoutée à l’implémentation de la mise à l’échelle automatique.

  • Les facteurs de mise à l’échelle sont désormais représentés sous forme de valeurs à virgule flottante, généralement à l’aide de la structure SizeF, afin que les erreurs d’arrondi aient été pratiquement éliminées.

Prudence

Les combinaisons arbitraires des modes de mise à l'échelle des polices et de PPP ne sont pas prises en charge. Bien que vous puissiez mettre à l’échelle un contrôle utilisateur en utilisant un mode (par exemple, DPI) et le placer sur un formulaire en utilisant un autre mode (Police) sans problème particulier, mélanger un formulaire de base dans un mode et un formulaire dérivé dans un autre peut entraîner des résultats inattendus.

Mise à l’échelle automatique en action

Windows Forms utilise désormais la logique suivante pour mettre automatiquement à l’échelle les formulaires et leur contenu :

  1. Au moment du design, chaque ContainerControl enregistre le mode de mise à l’échelle et sa résolution actuelle dans les AutoScaleMode et AutoScaleDimensions, respectivement.

  2. Au moment de l’exécution, la résolution réelle est stockée dans la propriété CurrentAutoScaleDimensions. La propriété AutoScaleFactor calcule dynamiquement le rapport entre la résolution de mise à l’échelle au moment de l’exécution et au moment du design.

  3. Lorsque le formulaire se charge, si les valeurs de CurrentAutoScaleDimensions et de AutoScaleDimensions sont différentes, la méthode PerformAutoScale est appelée pour mettre à l’échelle le contrôle et ses enfants. Cette méthode suspend la disposition et appelle la méthode Scale pour effectuer la mise à l’échelle réelle. Ensuite, la valeur de AutoScaleDimensions est mise à jour pour éviter une mise à l’échelle progressive.

  4. PerformAutoScale est également appelée automatiquement dans les situations suivantes :

    • En réponse à l’événement OnFontChanged si le mode de mise à l’échelle est Font.

    • Lorsque la disposition du contrôle conteneur reprend et qu’une modification est détectée dans les propriétés AutoScaleDimensions ou AutoScaleMode.

    • Comme indiqué ci-dessus, lorsqu’un ContainerControl parent est mis à l’échelle. Chaque contrôle de conteneur est responsable de la mise à l’échelle de ses enfants à l’aide de ses propres facteurs de mise à l'échelle, plutôt que de ceux de son conteneur parent.

  5. Les contrôles enfants peuvent modifier leur comportement de mise à l’échelle par plusieurs moyens :

    • La propriété ScaleChildren peut être substituée pour déterminer si leurs contrôles enfants doivent être mis à l’échelle ou non.

    • La méthode GetScaledBounds peut être substituée pour ajuster les limites auxquelles le contrôle est mis à l’échelle, mais pas la logique de mise à l’échelle.

    • La méthode ScaleControl peut être substituée pour modifier la logique de mise à l’échelle du contrôle actuel.

Voir aussi