Mise à l'échelle automatique dans les Windows Forms
La mise à l'échelle automatique permet à un formulaire et à ses contrôles, conçus sur un ordinateur avec une résolution d'écran et une police système particulières, de s'afficher correctement sur un autre ordinateur, avec une résolution d'écran ou une police système différente. Elle garantit que le formulaire et ses contrôles se redimensionneront de manière cohérente avec les fenêtres natives et d'autres applications sur les ordinateurs des autres développeurs et des utilisateurs. La prise en charge par le .NET Framework de la mise à l'échelle automatique et des styles visuels donnent aux applications .NET Framework une apparence cohérente par rapport aux applications Windows natives installées sur l'ordinateur des utilisateurs.
Besoin de mise à l'échelle automatique
Sans mise à l'échelle automatique, une application conçue pour une résolution d'écran ou une police particulière apparaîtra trop petite ou trop grande lorsque cette résolution ou police changera. Par exemple, si l'application est conçue avec la police Tahoma 9 points en ligne de base, sans réglage, elle apparaîtra trop petite si elle est exécutée sur un ordinateur où la police système est Tahoma 12 points, par exemple. Les éléments de texte tels que les titres, les menus, les contenus de zone de texte, et ainsi de suite apparaîtront plus petits que dans d'autres applications. En outre, la taille des éléments d'interface utilisateur qui contiennent du texte, tel 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 apparaîtront aussi relativement plus petits.
Une situation analogue se produit lorsqu'une application est conçue pour une certaine résolution d'écran. La résolution d'écran la plus commune est de 96 points par pouce (ppp), mais des résolutions de 120, 133, 170 ppp et supérieures sont de plus en plus fréquentes. Sans réglage, une application, et particulièrement une application graphique, conçue pour une résolution donnée apparaîtra trop grande ou trop petite exécutée dans une autre résolution.
La mise à l'échelle automatique cherche à améliorer ces problèmes en redimensionnant automatiquement le formulaire et ses contrôles enfants en fonction de la taille de police ou de la résolution d'écran relative. Le système d'exploitation Windows prend en charge la mise à l'échelle automatique des boîtes de dialogue à l'aide d'une unité de mesure relative, les unités de boîte de dialogue. Une unité de boîte de dialogue est basée sur la police système et sa relation aux pixels peut être déterminée par la fonction du Kit de développement Win32 (SDK) GetDialogBaseUnits. Lorsqu'un utilisateur change le thème utilisé par Windows, toutes les boîtes de dialogue sont automatiquement réglées en conséquence. De plus :
Le .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. La mise à l'échelle automatique peut être désactivée dans une application.
Prise en charge d'origine de la mise à l'échelle automatique
Les versions 1.0 et 1.1 du .NET Framework prenaient en charge la mise à l'échelle automatique d'une manière simple, qui dépendait de la police Windows utilisée par défaut pour l'interface utilisateur, représentée par la valeur DEFAULT_GUI_FONT du SDK Win32. En règle générale, cette police est modifiée uniquement lorsque la résolution d'écran change. Le mécanisme suivant a été utilisé pour implémenter la mise à l'échelle automatique :
Au moment du design, la propriété AutoScaleBaseSize (qui est maintenant déconseillée) avait la hauteur et la largeur de la police système par défaut sur l'ordinateur du développeur.
Pendant l'exécution, la police système par défaut de l'ordinateur de l'utilisateur était utilisée pour initialiser la propriété Font de la classe Form.
Avant d'afficher le formulaire, la méthode ApplyAutoScaling était appelée pour mettre le formulaire à l'échelle. Cette méthode calculait les tailles d'échelle relatives à partir de AutoScaleBaseSize et Font, puis appelait la méthode Scale pour procéder à la mise à l'échelle du formulaire et de ses enfants.
La valeur de AutoScaleBaseSize était mise à jour de sorte que les appels suivants à ApplyAutoScaling ne redimensionnent pas progressivement le formulaire.
Si ce mécanisme suffisait dans la plupart des cas, il souffrait des limitations suivantes :
Puisque la propriété AutoScaleBaseSize représente la taille de police de la ligne de base sous forme de valeurs intégrales, les erreurs d'arrondi apparaissent clairement lorsqu'un formulaire passe par plusieurs résolutions.
La mise à l'échelle automatique était implémentée uniquement dans la classe Form, pas dans la classe ContainerControl. Par conséquent, les contrôles utilisateur étaient correctement mis à l'échelle uniquement lorsqu'ils étaient conçus dans la même résolution que le formulaire, et placés dans le formulaire au moment du design.
Les formulaires et leurs contrôles enfants ne pouvaient être conçus par plusieurs développeurs à la fois que si leurs ordinateurs utilisaient la même résolution. De même, cela rendait également l'héritage d'un formulaire dépendant de la résolution associée au formulaire parent.
Il n'est pas compatible avec les gestionnaires de présentation les plus récents introduits par le .NET Framework version 2.0, tels que FlowLayoutPanel et TableLayoutPanel.
Il ne prenait pas en charge la mise à l'échelle basée directement sur la résolution d'affichage nécessaire pour être compatible avec .NET Compact Framework.
Bien que ce mécanisme soit conservé dans le .NET Framework version 2.0 pour des raisons de compatibilité descendante, il a été remplacé par un mécanisme de mise à l'échelle plus fiable décrit plus bas. Par conséquent, les AutoScale, ApplyAutoScaling, AutoScaleBaseSize et certaines surcharges Scale sont marquées comme obsolètes.
Notes
Vous pouvez supprimer sans risque les références à ces membres lorsque vous mettez à niveau votre code hérité vers le .NET Framework version 2.0.
Prise en charge actuelle de la mise à l'échelle automatique
Avec le .NET Framework version 2.0, ces limitations n'existent plus grâce aux modifications apportées à la mise à l'échelle automatique de Windows Forms :
La prise en charge de base de la mise à l'échelle a été placée dans la classe ContainerControl pour que les formulaires, les contrôles composites natifs et les contrôles utilisateur bénéficient tous d'une prise en charge de mise à l'échelle uniforme. Les nouveaux membres AutoScaleFactor, AutoScaleDimensions, AutoScaleMode et PerformAutoScale ont été ajoutés.
La classe Control dispose également de plusieurs nouveaux membres qui lui permettent de participer à mise à l'échelle et de prendre en charge la mise à l'échelle mixte sur un même formulaire. Spécifiquement, les membres Scale, ScaleChildren et 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 en complément de la prise en charge de la police système, conformément à la définition de l'énumération AutoScaleMode. Ce mode est compatible avec la mise à l'échelle automatique prise en charge par .NET Compact Framework, facilitant ainsi la migration des applications.
La compatibilité avec des gestionnaires de présentation tels que FlowLayoutPanel et TableLayoutPanel a été ajoutée à l'implémentation de la mise à l'échelle automatique.
Les facteurs d'échelle sont maintenant représentés sous forme de valeurs à virgule flottante, généralement avec la structure SizeF, de sorte que les erreurs d'arrondi sont pratiquement éliminées.
Avertissement
Les combinaisons arbitraires de modes de mise à l'échelle de police et de modes PPP ne sont pas prises en charge. Bien que vous puissiez mettre à l'échelle un contrôle utilisateur qui utilise un mode (par exemple, PPP) et le placer sur un formulaire qui utilise un autre mode (Police) sans problème, la combinaison d'un formulaire de base dans un mode et d'un formulaire dérivé dans un autre mode peut produire des résultats aléatoires.
Mise à l'échelle automatique en action
Windows Forms utilise désormais la logique suivante pour mettre automatiquement à l'échelle des formulaires et leur contenu :
Au moment du design, chaque ContainerControl enregistre le mode de mise à l'échelle et sa résolution actuelle dans AutoScaleMode et AutoScaleDimensions, respectivement.
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 taux entre la résolution de mise à l'échelle au moment de l'exécution et de la conception.
Lors du chargement du formulaire, si les valeurs de CurrentAutoScaleDimensions et 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 procéder à la mise à l'échelle. Après cela, la valeur de AutoScaleDimensions est mise à jour pour éviter la mise à l'échelle progressive.
PerformAutoScale est également appelé 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 impliqué ci-dessus, lorsqu'un ContainerControl parent est mis à l'échelle. Chaque contrôle conteneur est responsable de la mise à l'échelle de ses enfants à l'aide de ses propres facteurs d'échelle et non de ceux de son conteneur parent.
Les contrôles enfants peuvent modifier leur comportement de mise à l'échelle de plusieurs manières :
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 par rapport 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 pour le contrôle actuel.
Voir aussi
Tâches
Comment : activer des styles visuels de Windows XP
Comment : améliorer les performances en évitant la mise à l'échelle automatique