Partager via

Mise à l'échelle de l'écran et UI Automation

  • Article

Notes

Cette documentation s’adresse 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 dernières informations sur UI Automation, consultez API Windows Automation : UI Automation.

À partir de Windows Vista, Windows permet aux utilisateurs de changer le paramètre ppp (points par pouce) pour que la plupart des éléments d’IU (interface utilisateur) apparaissent plus grands à l’écran. Bien que cette fonctionnalité soit disponible depuis longtemps dans Windows, dans les versions antérieures, la mise à l’échelle devait être implémentée par les applications. À partir de Windows Vista, le Gestionnaire de fenêtrage 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 la largeur ou la hauteur d’un pouce fictif. La mesure exacte d’un « pouce » dépend de la taille et de la résolution physique du moniteur. Par exemple, sur un moniteur d’une largeur de 12 pouces, pour une résolution horizontale de 1 280 pixels, une ligne horizontale de 96 pixels s’étend sur 9/10e de pouce.

Changer le paramètre ppp et changer la résolution d’écran sont deux choses différentes. Avec la mise à l’échelle ppp, le nombre de pixels physiques à l’écran reste le même. Toutefois, la mise à l’échelle est appliquée à la taille et à l’emplacement des éléments d’IU. Cette mise à l’échelle peut être effectuée automatiquement par le Gestionnaire de fenêtrage (DWM, Desktop Window Manager) pour le bureau et pour les applications qui ne demandent pas explicitement à ne pas être mises à l’échelle.

En effet, quand l’utilisateur définit le facteur d’échelle à 120 ppp, un pouce vertical ou horizontal à l’écran s’agrandit de 25 %. Toutes les dimensions sont ajustées en conséquence. Le décalage d’une fenêtre d’application par rapport aux bords supérieur et gauche de l’écran augmente de 25 %. Si la mise à l’échelle de l’application est activée et si l’application ne prend pas en charge ppp, la taille de la fenêtre augmente dans les mêmes proportions, tout comme les décalages et les tailles de l’ensemble des éléments d’IU qu’elle contient.

Notes

Par défaut, le Gestionnaire de fenêtrage n’effectue pas de mise à l’échelle pour les applications qui ne prennent pas en charge ppp quand l’utilisateur définit la valeur du paramètre ppp à 120. Toutefois, il l’effectue quand le paramètre ppp a une valeur personnalisée égale ou supérieure à 144. Toutefois, l’utilisateur peut remplacer le comportement par défaut.

La mise à l’échelle de l’écran pose de nouveaux défis pour les applications qui sont concernées d’une manière ou d’une autre par les coordonnées d’écran. L’écran contient maintenant deux systèmes de coordonnées : l’un physique et l’autre logique. Les coordonnées physiques d’un point correspondent au décalage réel en pixels par rapport au point d’origine en haut à gauche. Les coordonnées logiques correspondent aux décalages tels qu’ils seraient si les pixels eux-mêmes étaient mis à l’échelle.

Supposons que vous concevez une boîte de dialogue avec un bouton aux coordonnées (100, 48). Quand cette boîte de dialogue s’affiche avec la valeur par défaut 96 ppp, le bouton se trouve aux coordonnées physiques (100, 48). À 120 ppp, il se trouve aux coordonnées physiques (125, 60). En revanche, les coordonnées logiques sont les mêmes, quel que soit le paramètre ppp : (100, 48).

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

Mise à l’échelle dans les clients UI Automation

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 utilisent comme paramètres.

Par défaut, une application cliente UI Automation qui s’exécute dans un environnement non défini à 96 ppp ne peut pas obtenir de résultats corrects à partir de ces méthodes et propriétés. Par exemple, comme la position du curseur est exprimée en coordonnées logiques, le client ne peut pas simplement passer ces coordonnées à FromPoint pour obtenir l’élément situé sous le curseur. En outre, l’application n’est pas en mesure de placer correctement les fenêtres en dehors de sa zone cliente.

La solution comporte deux parties.

  1. Tout d’abord, faites en sorte que l’application cliente prenne en charge ppp. Pour ce faire, appelez la fonction Win32 SetProcessDPIAware au démarrage. En 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 permet à l’ensemble du processus de prendre en charge ppp, ce qui signifie que toutes les fenêtres qui appartiennent au processus ne sont pas mises à l’échelle. Dans l’exemple Highlighter Sample, les quatre fenêtres qui composent le rectangle de sélection sont placées aux coordonnées physiques obtenues à partir de UI Automation, et non aux 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 Win32 GetPhysicalCursorPos. 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

Attention

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