Partager via

Automatisation de l'interface utilisateur et mise à l’échelle de l'écran

Remarque

Cette documentation est destinée aux développeurs .NET Framework qui souhaitent utiliser les classes UI Automation managées définies dans l’espace de noms System.Windows.Automation. Pour obtenir les informations les plus récentes sur UI Automation, consultez API Windows Automation : UI Automation.

À compter de Windows Vista, Windows permet aux utilisateurs de modifier le paramètre points par pouce (ppp) afin que la plupart des éléments d’interface utilisateur sur l’écran apparaissent plus grands. Bien que cette fonctionnalité ait été disponible depuis longtemps dans Windows, dans les versions précédentes, la mise à l’échelle devait être implémentée par les applications. À compter de Windows Vista, desktop Window Manager effectue une mise à l’échelle par défaut pour toutes les applications qui ne gèrent pas leur propre mise à l’échelle. Les applications clientes UI Automation doivent prendre en compte cette fonctionnalité.

Mise à l’échelle dans Windows Vista

Le paramètre ppp par défaut est 96, ce qui signifie que 96 pixels occupent une largeur ou une hauteur correspondant à une taille théorique d'un pouce. La mesure exacte d’un pouce dépend de la taille et de la résolution physique du moniteur. Par exemple, sur un moniteur de 12 pouces de large, à une résolution horizontale de 1280 pixels, une ligne horizontale de 96 pixels s’étend sur environ 9/10 d’un pouce.

La modification du paramètre ppp n’est pas la même chose que la modification de la résolution de l’écran. Avec la mise à l’échelle des DPI, le nombre de pixels physiques sur l’écran reste le même. Toutefois, la mise à l’échelle est appliquée à la taille et à l’emplacement des éléments d’interface utilisateur. Cette mise à l’échelle peut être effectuée automatiquement par le Gestionnaire de fenêtres de bureau (DWM) pour le bureau et pour les applications qui ne demandent pas explicitement de ne pas être mises à l’échelle.

En effet, lorsque l’utilisateur définit le facteur d’échelle sur 120 ppp, un pouce vertical ou horizontal sur l’écran devient plus grand de 25 %. Toutes les dimensions sont mises à l’échelle en conséquence. Le décalage d’une fenêtre d’application à partir des bords supérieur et gauche de l’écran augmente de 25 %. Si la mise à l’échelle de l’application est activée et que l’application ne prend pas en charge les DPI, la taille de la fenêtre augmente dans la même proportion, ainsi que les décalages et les tailles de tous les éléments de l'interface qu’elle contient.

Remarque

Par défaut, le DWM n’effectue pas de mise à l’échelle pour les applications non sensibilisées au ppp lorsque l’utilisateur définit le ppp sur 120, mais l’exécute lorsque le ppp est défini sur une valeur personnalisée de 144 ou plus. Toutefois, l’utilisateur peut remplacer le comportement par défaut.

La mise à l’échelle de l’écran crée de nouveaux défis pour les applications qui sont concernées de quelque manière que ce soit par les coordonnées de l’écran. L’écran contient maintenant deux systèmes de coordonnées : physique et logique. Les coordonnées physiques d’un point sont le décalage réel en pixels du haut à gauche de l’origine. Les coordonnées logiques sont les décalages tels qu’ils le seraient si les pixels eux-mêmes ont été mis à l’échelle.

Supposons que vous conceviez une boîte de dialogue avec un bouton aux coordonnées (100, 48). Lorsque cette boîte de dialogue s’affiche à 96 ppp par défaut, le bouton se trouve aux coordonnées physiques de (100, 48). À 120 ppp, il se trouve aux coordonnées physiques de (125, 60). Mais les coordonnées logiques sont identiques à n’importe quel paramètre ppp : (100, 48).

Les coordonnées logiques sont importantes, car elles rendent le comportement du système d’exploitation et des applications cohérents, quel que soit le réglage ppp. Par exemple, Cursor.Position retourne normalement les coordonnées logiques. Si vous déplacez le curseur sur un élément d’une boîte de dialogue, les mêmes coordonnées sont retournées, peu importe le paramètre de ppp. Si vous dessinez un contrôle à (100, 100), il est dessiné à ces coordonnées logiques et conservera la même position relative quel que soit le paramètre DPI.

Mise à l’échelle dans les applications d'automatisation de l'interface utilisateur.

L’API UI Automation n’utilise pas de coordonnées logiques. Les méthodes et propriétés suivantes retournent des coordonnées physiques ou les prennent comme paramètres.

Par défaut, une application cliente UI Automation s’exécutant dans un environnement non 96 ppp ne pourra pas obtenir les résultats corrects de ces méthodes et propriétés. Par exemple, étant donné que la position du curseur se trouve dans des coordonnées logiques, le client ne peut pas simplement passer ces coordonnées pour FromPoint obtenir l’élément qui se trouve sous le curseur. En outre, l’application ne pourra pas placer correctement les fenêtres en dehors de sa zone cliente.

La solution se trouve en deux parties.

  1. Tout d’abord, faites en sorte que l’application cliente soit compatible avec les DPI. Pour ce faire, appelez la fonction SetProcessDPIAware Win32 au démarrage. Dans le code managé, la déclaration suivante rend cette fonction disponible.

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

    <System.Runtime.InteropServices.DllImport("user32.dll")> _
Friend Shared Function SetProcessDPIAware() As Boolean
End Function

    Cette fonction rend l’ensemble du processus compatible avec la résolution DPI, ce qui permet à toutes les fenêtres appartenant au processus d'être affichées sans mise à l'échelle. Dans l’exemple De surligneur, par exemple, les quatre fenêtres qui composent le rectangle de mise en surbrillance se trouvent sur les coordonnées physiques obtenues à partir d’UI Automation, et non sur les coordonnées logiques. Si l’exemple ne prenait pas en charge ppp, la sélection serait dessinée aux coordonnées logiques sur le Bureau, ce qui entraînerait un positionnement incorrect dans un environnement non défini à 96 ppp.

  2. Pour obtenir les coordonnées du curseur, appelez la fonction GetPhysicalCursorPosWin32 . L’exemple suivant montre comment déclarer et utiliser cette fonction.

    public struct CursorPoint
{
    public int X;
    public int Y;
}

[System.Runtime.InteropServices.DllImport("user32.dll")]
internal static extern bool GetPhysicalCursorPos(ref CursorPoint lpPoint);

private bool ShowUsage()
{
    CursorPoint cursorPos = new CursorPoint();
    try
    {
        return GetPhysicalCursorPos(ref cursorPos);
    }
    catch (EntryPointNotFoundException) // Not Windows Vista
    {
        return false;
    }
}

    Structure CursorPoint
    Public X As Integer
    Public Y As Integer
End Structure

<System.Runtime.InteropServices.DllImport("user32.dll")> _
Friend Shared Function GetPhysicalCursorPos(ByRef lpPoint As CursorPoint) As Boolean
End Function

Private Function ShowUsage() As Boolean

    Dim cursorPos As New CursorPoint()
    Try
        Return GetPhysicalCursorPos(cursorPos)
    Catch e As EntryPointNotFoundException ' Not Windows Vista
        Return False
    End Try

End Function

Avertissement

N’utilisez pas Cursor.Position. Le comportement de cette propriété en dehors des fenêtres clientes dans un environnement à l’échelle n’est pas défini.

Si votre application effectue une communication interprocessus directe avec des applications qui ne prennent pas en charge ppp, vous pouvez être amené à effectuer une conversion entre les coordonnées logiques et physiques à l’aide des fonctions Win32 PhysicalToLogicalPoint et LogicalToPhysicalPoint.

Voir aussi

  • Last updated on