Vue d’ensemble du rendu graphique WPF

Cette rubrique fournit une vue d’ensemble de la couche visuelle WPF. Il se concentre sur le rôle de la classe Visual pour la prise en charge du rendu dans le modèle WPF.

Rôle de l’objet visuel

La classe Visual est l’abstraction de base à partir de laquelle chaque objet FrameworkElement dérive. Elle sert également de point d’entrée pour l’écriture de nouveaux contrôles dans WPF et peut être considérée de diverses manières comme le handle de fenêtre (HWND) dans le modèle d’application Win32.

L’objet Visual est un objet WPF principal, dont le rôle principal est de fournir la prise en charge du rendu. Les contrôles d’interface utilisateur, tels que Button et TextBox, dérivent de la classe Visual et l’utilisent pour conserver leurs données de rendu. L’objet Visual prend en charge les éléments suivants :

• Affichage de sortie : rendu du contenu de dessin persistant et sérialisé d’un visuel.

• Transformations : exécution de transformations sur un visuel.

• Détourage : prise en charge de la zone de détourage d’un objet visuel.

• Test des résultats : détermination si une coordonnée ou une géométrie est contenue dans les limites d’un objet visuel.

• Calculs de rectangle englobant : détermination du rectangle englobant d’un objet visuel.

Toutefois, l’objet Visual n’inclut pas la prise en charge des fonctionnalités non de rendu, telles que :

• Gestion des événements

• Mise en page

• Styles

• Liaison de données

• Mondialisation

Visual est exposé comme une classe abstraite publique à partir de laquelle les classes enfants doivent être dérivées. L’illustration suivante montre la hiérarchie des objets visuels exposés dans WPF.

Classe DrawingVisual

Le DrawingVisual est une classe de dessin légère utilisée pour afficher des formes, des images ou du texte. Cette classe est considérée comme légère, car elle ne fournit pas de gestion des événements ou de disposition, ce qui améliore ses performances d’exécution. Pour cette raison, les dessins sont idéaux pour les arrière-plans et les images clipart. Le DrawingVisual peut être utilisé pour créer un objet visuel personnalisé. Pour plus d’informations, consultez Utilisation d’objets DrawingVisual.

Classe Viewport3DVisual

Le Viewport3DVisual fournit un pont entre les objets 2D Visual et Visual3D. La classe Visual3D est la classe de base pour tous les éléments visuels 3D. La Viewport3DVisual exige que vous définissiez une valeur Camera et une valeur Viewport. La caméra vous permet de voir la scène. La fenêtre d’affichage détermine où la projection est mappée sur la surface 2D. Pour plus d’informations sur la 3D dans WPF, consultez vue d’ensemble des graphiques 3D.

Classe ContainerVisual

La classe ContainerVisual est utilisée comme conteneur pour une collection d’objets Visual. La classe DrawingVisual dérive de la classe ContainerVisual, ce qui lui permet de contenir une collection d’objets visuels.

Création de contenu dans des objets visuels

Un objet Visual stocke ses données de rendu sous la forme d’une liste d’instructions graphiques vectorielles . Chaque élément de la liste d’instructions représente un jeu de données graphiques de bas niveau et des ressources associées dans un format sérialisé. Il existe quatre types de données de rendu différents qui peuvent contenir du contenu de dessin.

Type de contenu de dessin	Description
Graphiques vectoriels	Représente les données graphiques vectorielles et toutes les informations Brush et Pen associées.
Image	Représente une image dans une région définie par un Rect.
Glyphe	Représente un dessin qui restitue un GlyphRun, qui est une séquence de glyphes d’une ressource de police spécifiée. Il s’agit de la façon dont le texte est représenté.
Vidéo	Représente un dessin qui restitue la vidéo.

La DrawingContext vous permet de remplir un Visual avec du contenu visuel. Lorsque vous utilisez des commandes de dessin d’un objet DrawingContext, vous stockez en fait un ensemble de données de rendu qui seront ultérieurement utilisées par le système graphique ; vous ne dessinez pas à l’écran en temps réel.

Lorsque vous créez un contrôle WPF, tel qu’un Button, le contrôle génère implicitement des données de rendu pour le dessin lui-même. Par exemple, la définition de la propriété Content de l'Button entraîne le stockage d’une représentation de rendu d’un glyphe.

Un Visual décrit son contenu en tant qu’un ou plusieurs objets Drawing contenus dans un DrawingGroup. Un DrawingGroup décrit également les masques d’opacité, les transformations, les effets bitmap et d’autres opérations appliquées à son contenu. DrawingGroup opérations sont appliquées dans l’ordre suivant lorsque le contenu est rendu : OpacityMask, Opacity, BitmapEffect, ClipGeometry, GuidelineSet, puis Transform.

L’illustration suivante montre l’ordre dans lequel les opérations DrawingGroup sont appliquées pendant la séquence de rendu.

Ordre des opérations de DrawingGroup

Pour plus d’informations, consultez Vue d’ensemble des objets de dessin.

Dessiner le contenu au niveau de la couche visuelle

Vous n’instanciez jamais directement un DrawingContext; vous pouvez toutefois acquérir un contexte de dessin à partir de certaines méthodes, telles que DrawingGroup.Open et DrawingVisual.RenderOpen. L’exemple suivant récupère une DrawingContext à partir d’un DrawingVisual et l’utilise pour dessiner un rectangle.

// Create a DrawingVisual that contains a rectangle.
private DrawingVisual CreateDrawingVisualRectangle()
{
    DrawingVisual drawingVisual = new DrawingVisual();

    // Retrieve the DrawingContext in order to create new drawing content.
    DrawingContext drawingContext = drawingVisual.RenderOpen();

    // Create a rectangle and draw it in the DrawingContext.
    Rect rect = new Rect(new System.Windows.Point(160, 100), new System.Windows.Size(320, 80));
    drawingContext.DrawRectangle(System.Windows.Media.Brushes.LightBlue, (System.Windows.Media.Pen)null, rect);

    // Persist the drawing content.
    drawingContext.Close();

    return drawingVisual;
}

' Create a DrawingVisual that contains a rectangle.
Private Function CreateDrawingVisualRectangle() As DrawingVisual
    Dim drawingVisual As New DrawingVisual()

    ' Retrieve the DrawingContext in order to create new drawing content.
    Dim drawingContext As DrawingContext = drawingVisual.RenderOpen()

    ' Create a rectangle and draw it in the DrawingContext.
    Dim rect As New Rect(New Point(160, 100), New Size(320, 80))
    drawingContext.DrawRectangle(Brushes.LightBlue, CType(Nothing, Pen), rect)

    ' Persist the drawing content.
    drawingContext.Close()

    Return drawingVisual
End Function

Énumération du contenu de dessin au niveau de la couche visuelle

En plus de leurs autres utilisations, Drawing objets fournissent également un modèle objet pour énumérer le contenu d’un Visual.

Remarque

Lorsque vous énumérez le contenu du visuel, vous récupérez des objets Drawing et non la représentation sous-jacente des données de rendu en tant que liste d’instructions graphiques vectorielles.

L’exemple suivant utilise la méthode GetDrawing pour récupérer la valeur DrawingGroup d’un Visual et l’énumérer.

public void RetrieveDrawing(Visual v)
{
    DrawingGroup drawingGroup = VisualTreeHelper.GetDrawing(v);
    EnumDrawingGroup(drawingGroup);
}

// Enumerate the drawings in the DrawingGroup.
public void EnumDrawingGroup(DrawingGroup drawingGroup)
{
    DrawingCollection dc = drawingGroup.Children;

    // Enumerate the drawings in the DrawingCollection.
    foreach (Drawing drawing in dc)
    {
        // If the drawing is a DrawingGroup, call the function recursively.
        if (drawing is DrawingGroup group)
        {
            EnumDrawingGroup(group);
        }
        else if (drawing is GeometryDrawing)
        {
            // Perform action based on drawing type.
        }
        else if (drawing is ImageDrawing)
        {
            // Perform action based on drawing type.
        }
        else if (drawing is GlyphRunDrawing)
        {
            // Perform action based on drawing type.
        }
        else if (drawing is VideoDrawing)
        {
            // Perform action based on drawing type.
        }
    }
}

Utilisation des objets visuels pour générer des contrôles

La plupart des objets de WPF sont composés d’autres objets visuels, ce qui signifie qu’ils peuvent contenir des hiérarchies variables d’objets descendants. La plupart des éléments d’interface utilisateur dans WPF, tels que les contrôles, sont composés de plusieurs objets visuels, représentant différents types d’éléments de rendu. Par exemple, le contrôle Button peut contenir un certain nombre d’autres objets, notamment ClassicBorderDecorator, ContentPresenteret TextBlock.

Le code suivant montre un contrôle Button défini dans le balisage.

<Button Click="OnClick">OK</Button>

Si vous deviez énumérer les objets visuels qui composent le contrôle Button par défaut, vous trouverez la hiérarchie des objets visuels illustrés ci-dessous :

Diagramme

Le contrôle Button contient un élément ClassicBorderDecorator qui, à son tour, contient un élément ContentPresenter. L’élément ClassicBorderDecorator est chargé de dessiner une bordure et un arrière-plan pour le Button. L’élément ContentPresenter est chargé d’afficher le contenu du Button. Dans ce cas, étant donné que vous affichez du texte, l’élément ContentPresenter contient un élément TextBlock. Le fait que le contrôle Button utilise un ContentPresenter signifie que le contenu peut être représenté par d’autres éléments, tels qu’un Image ou une géométrie, tel qu’un EllipseGeometry.

Modèles de contrôle

La clé de l’expansion d’un contrôle dans une hiérarchie de contrôles est la ControlTemplate. Un modèle de contrôle spécifie la hiérarchie visuelle par défaut d’un contrôle. Lorsque vous référencez explicitement un contrôle, vous référencez implicitement sa hiérarchie visuelle. Vous pouvez remplacer les valeurs par défaut d’un modèle de contrôle pour créer une apparence visuelle personnalisée pour un contrôle. Par exemple, vous pouvez modifier la valeur de couleur d’arrière-plan du contrôle Button afin qu’il utilise une valeur de couleur de dégradé linéaire au lieu d’une valeur de couleur unie. Pour plus d’informations, consultez Styles de bouton et modèles.

Un élément d’interface utilisateur, tel qu’un contrôle Button, contient plusieurs listes d’instructions graphiques vectorielles qui décrivent l’intégralité de la définition de rendu d’un contrôle. Le code suivant montre un contrôle Button défini dans le balisage.

<Button Click="OnClick">
  <Image Source="images\greenlight.jpg"></Image>
</Button>

Si vous deviez énumérer les objets visuels et les listes d’instructions graphiques vectorielles qui composent le contrôle Button, vous trouverez la hiérarchie des objets illustrés ci-dessous :

Diagramme de l'arborescence visuelle et des données de rendu

Le contrôle Button contient un élément ClassicBorderDecorator qui, à son tour, contient un élément ContentPresenter. L’élément ClassicBorderDecorator est chargé de dessiner tous les éléments graphiques discrets qui composent la bordure et l’arrière-plan d’un bouton. L’élément ContentPresenter est chargé d’afficher le contenu du Button. Dans ce cas, étant donné que vous affichez une image, l’élément ContentPresenter contient un élément Image.

Il existe plusieurs points à noter sur la hiérarchie des objets visuels et des listes d’instructions graphiques vectorielles :

• L’ordre dans la hiérarchie représente l’ordre de rendu des informations de dessin. À partir de l’élément visuel racine, les éléments enfants sont parcourus de gauche à droite et de haut en bas. Si un élément comporte des éléments enfants, ils sont parcourus avant les frères de l’élément.

• Les éléments de nœuds non terminaux dans la hiérarchie, tels que ContentPresenter, sont utilisés pour contenir des éléments enfants, ils ne contiennent pas de listes d’instructions.

• Si un élément visuel contient une liste d’instructions de graphismes vectoriels et des enfants visuels, la liste d’instructions de l’élément visuel parent est rendue avant les dessins des objets enfants visuels.

• Les éléments de la liste d’instructions graphiques vectorielles sont rendus de gauche à droite.

Arborescence d'éléments visuels

L’arborescence visuelle contient tous les éléments visuels utilisés dans l’interface utilisateur d’une application. Étant donné qu’un élément visuel contient des informations de dessin persistantes, vous pouvez considérer l’arborescence visuelle comme un graphe de scène, contenant toutes les informations de rendu nécessaires pour composer la sortie sur l’appareil d’affichage. Cette arborescence est l’accumulation de tous les éléments visuels créés directement par l’application, que ce soit dans le code ou dans le balisage. L’arborescence visuelle contient également tous les éléments visuels créés par l’expansion du modèle d’éléments tels que les contrôles et les objets de données.

Le code suivant montre un élément StackPanel défini dans le balisage.

<StackPanel>
  <Label>User name:</Label>
  <TextBox />
  <Button Click="OnClick">OK</Button>
</StackPanel>

Si vous deviez énumérer les objets visuels qui composent l’élément StackPanel dans l’exemple de balisage, vous trouverez la hiérarchie des objets visuels illustrés ci-dessous :

Ordre de rendu

L’arborescence d’éléments visuels détermine l’ordre de rendu des objets visuels et de dessin WPF. L’ordre de traversée commence par la racine visuelle, qui est le nœud supérieur dans l’arborescence visuelle. Les enfants de l’objet visuel racine sont ensuite parcourus de gauche à droite. Si un objet visuel comporte des enfants, ses enfants sont parcourus avant les frères de l’objet visuel. Cela signifie que le contenu d’un objet visuel enfant est rendu avant le contenu de l’objet visuel.

Diagramme

Objet visuel racine

L’objet visuel racine est le premier élément d’une hiérarchie d’arborescence d’éléments visuels. Dans la plupart des applications, la classe de base du visuel racine est Window ou NavigationWindow. Toutefois, si vous hébergez des objets visuels dans une application Win32, le visuel racine serait le visuel le plus haut que vous hébergeiez dans la fenêtre Win32. Pour plus d’informations, consultez Tutoriel : Hébergement d’objets visuels dans une application Win32.

Relation à l’arborescence logique

L’arborescence logique dans WPF représente les éléments d’une application au moment de l’exécution. Bien que vous ne manipulez pas directement cette arborescence, cette vue de l’application est utile pour comprendre l’héritage des propriétés et le routage des événements. Contrairement à l’arborescence visuelle, l’arborescence logique peut représenter des objets de données non visuels, tels que ListItem. Dans de nombreux cas, l’arborescence logique correspond très étroitement aux définitions de balisage d’une application. Le code suivant montre un élément DockPanel défini dans le balisage.

<DockPanel>
  <ListBox>
    <ListBoxItem>Dog</ListBoxItem>
    <ListBoxItem>Cat</ListBoxItem>
    <ListBoxItem>Fish</ListBoxItem>
  </ListBox>
  <Button Click="OnClick">OK</Button>
</DockPanel>

Si vous deviez énumérer les objets logiques qui composent l’élément DockPanel dans l’exemple de balisage, vous trouverez la hiérarchie des objets logiques illustrés ci-dessous :

diagramme d’arborescence
Diagramme de l’arborescence logique

L’arborescence visuelle et l’arborescence logique sont synchronisées avec l’ensemble actuel d’éléments d’application, reflétant tout ajout, suppression ou modification d’éléments. Toutefois, les arborescences présentent différentes vues de l’application. Contrairement à l’arborescence visuelle, l’arborescence logique ne développe pas l’élément ContentPresenter d’un contrôle. Cela signifie qu’il n’existe pas de correspondance directe un-à-un entre une arborescence logique et une arborescence visuelle pour le même ensemble d’objets. En effet, l’appel de la méthode GetChildren de l’objet LogicalTreeHelper et de la méthode GetChild de l’objet VisualTreeHelper à l’aide du même élément qu’un paramètre génère des résultats différents.

Pour plus d’informations sur l’arborescence logique, consultez Arborescences dans WPF.

Affichage de l’arborescence visuelle avec XamlPad

L’outil WPF, XamlPad, offre une option permettant d’afficher et d’explorer l’arborescence visuelle qui correspond au contenu XAML actuellement défini. Cliquez sur le bouton Afficher l’arborescence visuelle dans la barre de menus pour afficher l’arborescence visuelle. L’exemple suivant illustre l’expansion du contenu XAML dans des nœuds d’arborescence d’éléments visuels dans le volet Explorateur de l’arborescence d’éléments visuels de XamlPad :

panneau

Notez comment les contrôles Label, TextBoxet Button affichent chacune une hiérarchie d’objets visuels distincte dans le panneau 'Explorateur d’arborescences visuelles de XamlPad. Cela est dû au fait que les contrôles WPF ont un ControlTemplate qui contient l’arborescence visuelle de ce contrôle. Lorsque vous référencez explicitement un contrôle, vous référencez implicitement sa hiérarchie visuelle.

Profilage des performances visuelles

WPF fournit une suite d’outils de profilage des performances qui vous permettent d’analyser le comportement d’exécution de votre application et de déterminer les types d’optimisations des performances que vous pouvez appliquer. L’outil Visual Profiler fournit une vue graphique complète des données de performances en mappant directement à l’arborescence visuelle de l’application. Dans cette capture d’écran, la section utilisation du processeur du Profileur visuel vous donne une répartition précise de l’utilisation des services WPF, tels que le rendu et la disposition d’un objet.

Sortie d’affichage Visual Profiler

Comportement de rendu visuel

WPF introduit plusieurs fonctionnalités qui affectent le comportement de rendu des objets visuels : graphiques en mode conservé, graphiques vectoriels et graphiques indépendants de l’appareil.

Graphiques en mode retenu

Une des clés pour comprendre le rôle de l’objet visuel est de comprendre la différence entre les systèmes graphiques en mode exécution et en mode retenu. Une application Win32 standard basée sur GDI ou GDI+ utilise un système graphique en mode immédiat. Cela signifie que l’application est chargée de repeindre la partie de la zone cliente invalidée, en raison d’une action telle qu’une fenêtre redimensionnée ou d’un objet modifiant son apparence visuelle.

Diagramme

En revanche, WPF utilise un système en mode conservé. Cela signifie que les objets d’application qui ont une apparence visuelle définissent un ensemble de données de dessin sérialisées. Une fois les données de dessin définies, le système est ensuite chargé de répondre à toutes les demandes de repeinture pour le rendu des objets de l'application. Même au moment de l’exécution, vous pouvez modifier ou créer des objets d’application, et toujours s’appuyer sur le système pour répondre aux demandes de peinture. La puissance d’un système graphique en mode conservé réside dans le fait que les informations de dessin sont toujours conservées dans un état sérialisé par l’application, mais la responsabilité du rendu incombe au système. Le diagramme suivant montre comment l’application s’appuie sur WPF pour répondre aux demandes de peinture.

diagramme

Nouveau dessin intelligent

L’un des principaux avantages de l’utilisation de graphiques en mode conservé est que WPF peut optimiser efficacement ce qui doit être redessiné dans l’application. Même si vous avez une scène complexe avec différents niveaux d’opacité, vous n’avez généralement pas besoin d’écrire du code à usage spécial pour optimiser le redessinage. Comparez cela à la programmation Win32 dans laquelle vous pouvez dépenser beaucoup d’efforts pour optimiser votre application en réduisant la quantité de redessination dans la région de mise à jour. Consultez Redessinage dans la région de mise à jour pour un exemple de type de complexité impliquée dans l’optimisation du redessinage dans les applications Win32.

Graphiques vectoriels

WPF utilise les graphiques vectoriels comme format de données de rendu. Graphiques vectoriels( qui incluent SVG (Scalable Vector Graphics), les métafichiers Windows (.wmf) et les polices TrueType, stockent les données de rendu et les transmettent sous la forme d’une liste d’instructions qui décrivent comment recréer une image à l’aide de primitives graphiques. Par exemple, les polices TrueType sont des polices de plan qui décrivent un ensemble de lignes, de courbes et de commandes, plutôt qu’un tableau de pixels. L’un des principaux avantages des graphiques vectoriels est la possibilité d’effectuer une mise à l’échelle vers n’importe quelle taille et résolution.

Contrairement aux graphiques vectoriels, les graphiques bitmap stockent les données de rendu sous la forme d’une représentation pixel par pixel d’une image, pré-restituée pour une résolution spécifique. L’une des principales différences entre les formats de graphique bitmap et vectoriel est la fidélité à l’image source d’origine. Par exemple, lorsque la taille d’une image source est modifiée, les systèmes graphiques bitmap étirent l’image, tandis que les systèmes graphiques vectoriels mettent l’image à l’échelle, tout en préservant la fidélité de l’image.

L’illustration suivante montre une image source qui a été redimensionnée de 300%. Notez les distorsions qui apparaissent lorsque l’image source est étirée en tant qu’image graphique bitmap plutôt que mise à l’échelle en tant qu’image graphique vectorielle.

Différences

Le balisage suivant montre deux éléments Path définis. Le deuxième élément utilise un ScaleTransform pour redimensionner de 300%les instructions de dessin du premier élément. Notez que les instructions de dessin des éléments Path restent inchangées.

<Path
  Data="M10,100 C 60,0 100,200 150,100 z"
  Fill="{StaticResource linearGradientBackground}"
  Stroke="Black"
  StrokeThickness="2" />

<Path
  Data="M10,100 C 60,0 100,200 150,100 z"
  Fill="{StaticResource linearGradientBackground}"
  Stroke="Black"
  StrokeThickness="2" >
  <Path.RenderTransform>
    <ScaleTransform ScaleX="3.0" ScaleY="3.0" />
  </Path.RenderTransform>
</Path>

À propos des graphiques indépendants de la résolution et du périphérique

Deux facteurs système déterminent la taille du texte et des graphiques sur votre écran : la résolution et les points par pouce (PPP). La résolution décrit le nombre de pixels qui apparaissent sur l’écran. À mesure que la résolution est supérieure, les pixels sont plus petits, ce qui entraîne l’apparition de graphiques et de texte plus petits. Un graphique affiché sur un moniteur défini sur 1024 x 768 apparaît beaucoup plus petit lorsque la résolution est remplacée par 1600 x 1200.

L'autre paramètre système, DPI, décrit la taille d'un pouce d'écran en pixels. La plupart des systèmes Windows ont un PPP de 96, ce qui signifie qu’un pouce d’écran est de 96 pixels. L’augmentation du paramètre PPP rend le pouce d’écran plus grand ; la réduction du paramètre PPP rend le pouce d’écran plus petit. Cela signifie qu’un pouce d’écran n’est pas de la même taille qu’un pouce réel ; sur la plupart des systèmes, ce n’est probablement pas le cas. Lorsque vous augmentez le paramètre PPP, les graphiques et le texte reconnaissant la résolution sont plus volumineux car vous avez augmenté la taille du pouce d’écran. L’augmentation du paramètre PPP peut rendre du texte plus facile à lire, notamment à des hautes résolutions.

Toutes les applications ne sont pas optimisées pour le PPP : certaines utilisent les pixels matériels comme unité principale de mesure ; la modification du PPP du système n’a aucun effet sur ces applications. Beaucoup d’autres applications utilisent des unités reconnaissant la résolution pour décrire les tailles de police, mais utilisent des pixels pour décrire tout le reste. La définition du paramètre PPP sur une valeur trop basse ou trop élevée peut entraîner des problèmes de disposition pour ces applications, car le texte des applications évolue avec le paramètre PPP du système, mais pas l’interface utilisateur des applications. Ce problème a été éliminé pour les applications développées à l’aide de WPF.

WPF prend en charge la mise à l’échelle automatique à l’aide du pixel indépendant de l’appareil comme unité de mesure principale, au lieu de pixels matériels ; Les graphiques et le texte sont mis à l’échelle correctement sans aucun travail supplémentaire du développeur d’applications. L’illustration suivante montre un exemple de la façon dont le texte et les graphiques WPF apparaissent à différents paramètres DPI.

Graphiques et texte à différents paramètres DPI

Classe VisualTreeHelper

La classe VisualTreeHelper est une classe d’assistance statique qui fournit des fonctionnalités de bas niveau pour la programmation au niveau de l’objet visuel, ce qui est utile dans des scénarios très spécifiques, tels que le développement de contrôles personnalisés hautes performances. Dans la plupart des cas, les objets d’infrastructure WPF de niveau supérieur, tels que Canvas et TextBlock, offrent une plus grande flexibilité et une facilité d’utilisation.

Test des résultats

La classe VisualTreeHelper fournit des méthodes pour la détection de collision sur les objets visuels lorsque la prise en charge par défaut de ces tests ne répond pas à vos besoins. Vous pouvez utiliser les méthodes HitTest dans la classe VisualTreeHelper pour déterminer si une valeur de coordonnée de géométrie ou de point se trouve à l'intérieur de la limite d’un objet donné, tel qu’un élément de contrôle ou un élément graphique. Par exemple, vous pouvez utiliser le test d’accès pour déterminer si un clic de souris dans le rectangle englobant d’un objet se trouve dans la géométrie d’un cercle, vous pouvez également choisir de remplacer l’implémentation par défaut des tests d’accès pour effectuer vos propres calculs de test d’accès personnalisés.

Pour plus d’informations sur les tests de collision, consultez Tests de collision dans la couche visuelle.

Énumération de l’arborescence d’éléments visuels

La classe VisualTreeHelper fournit des fonctionnalités permettant d’énumérer les membres d’une arborescence visuelle. Pour récupérer un parent, appelez la méthode GetParent. Pour récupérer un enfant ou un descendant direct d’un objet visuel, appelez la méthode GetChild. Cette méthode retourne un enfant Visual du parent au niveau de l’index spécifié.

L’exemple suivant montre comment énumérer tous les descendants d’un objet visuel, qui est une technique que vous souhaiterez peut-être utiliser si vous souhaitez sérialiser toutes les informations de rendu d’une hiérarchie d’objets visuels.

// Enumerate all the descendants of the visual object.
static public void EnumVisual(Visual myVisual)
{
    for (int i = 0; i < VisualTreeHelper.GetChildrenCount(myVisual); i++)
    {
        // Retrieve child visual at specified index value.
        Visual childVisual = (Visual)VisualTreeHelper.GetChild(myVisual, i);

        // Do processing of the child visual object.

        // Enumerate children of the child visual object.
        EnumVisual(childVisual);
    }
}

' Enumerate all the descendants of the visual object.
Public Shared Sub EnumVisual(ByVal myVisual As Visual)
    For i As Integer = 0 To VisualTreeHelper.GetChildrenCount(myVisual) - 1
        ' Retrieve child visual at specified index value.
        Dim childVisual As Visual = CType(VisualTreeHelper.GetChild(myVisual, i), Visual)

        ' Do processing of the child visual object.

        ' Enumerate children of the child visual object.
        EnumVisual(childVisual)
    Next i
End Sub

Dans la plupart des cas, l’arborescence logique est une représentation plus utile des éléments dans une application WPF. Bien que vous ne modifiez pas directement l’arborescence logique, cette vue de l’application est utile pour comprendre l’héritage des propriétés et le routage des événements. Contrairement à l’arborescence visuelle, l’arborescence logique peut représenter des objets de données non visuels, tels que ListItem. Pour plus d'informations sur l'arborescence logique, consultez la section Arborescences dans WPF.

La classe VisualTreeHelper fournit des méthodes pour retourner le rectangle englobant d’objets visuels. Vous pouvez retourner le rectangle englobant d’un objet visuel en appelant GetContentBounds. Vous pouvez retourner le rectangle englobant de tous les descendants d’un objet visuel, y compris l’objet visuel lui-même, en appelant GetDescendantBounds. Le code suivant montre comment calculer le rectangle englobant d’un objet visuel et de tous ses descendants.

// Return the bounding rectangle of the parent visual object and all of its descendants.
Rect rectBounds = VisualTreeHelper.GetDescendantBounds(parentVisual);

' Return the bounding rectangle of the parent visual object and all of its descendants.
Dim rectBounds As Rect = VisualTreeHelper.GetDescendantBounds(parentVisual)

Voir aussi

• Visual
• VisualTreeHelper
• DrawingVisual
• Imagerie et graphiques 2D
• Test de collision dans la couche visuelle
• Utilisation d’objets DrawingVisual
• Didacticiel : hébergement d’objets visuels dans une application Win32
• Optimisation des performances des applications WPF