Introduction à Windows Presentation Foundation

Mise à jour : novembre 2007

Windows Presentation Foundation (WPF) est un système de présentation nouvelle génération qui génère des applications clientes Windows avec des expériences utilisateur visuellement surprenantes. Avec WPF, vous pouvez créer une large gamme d'applications autonomes et d'applications hébergées par un navigateur.Messenger, New York Times Reader, ainsi que Contoso Healthcare Sample Application (voir l'illustration ci-dessous).

Le noyau de WPF est un moteur de rendu vectoriel indépendant de toute résolution conçu pour tirer parti du matériel vidéo moderne. WPF étend ce noyau avec un jeu complet de fonctionnalités de développement d'applications qui incluent XAML (Extensible Application Markup Language), les contrôles, la liaison de données, la disposition, les graphiques 2D et 3D, l'animation, les styles, les modèles, les documents, les médias, le texte et la typographie. WPF est inclus dans Microsoft .NET Framework ; vous pouvez donc générer des applications qui incorporent d'autres éléments de la bibliothèque de classes .NET Framework.

Cette vue d'ensemble est destinée aux utilisateurs inexpérimentés ; elle couvre les fonctions et les concepts clés de WPF. Cette vue d'ensemble peut également être utile aux développeurs WPF expérimentés souhaitant passer en revue WPF.

Remarque :
Pour obtenir la liste des fonctionnalités WPF nouvelles et mises à jour du .NET Framework 3.5, consultez Nouveautés de Windows Presentation Foundation version 3.5.

Cette rubrique comprend les sections suivantes.

• Programmation avec WPF
• Balisage et code-behind
• Applications
• Contrôles
• Entrée et commande
• Disposition
• Liaison de données
• Graphiques
• Animation
• Médias
• Texte et typographie
• Documents
• Personnalisation des applications WPF
• Meilleures pratiques WPF
• Résumé
• Vues d'ensemble et exemples recommandés
• Rubriques connexes

Programmation avec WPF

WPF existe en tant que sous-ensemble des types .NET Framework situés, pour la plupart, dans l'espace de noms System.Windows. S'il vous est déjà arrivé de générer des applications avec .NET Framework à l'aide de technologies managées comme ASP.NET et Windows Forms, la programmation fondamentale de WPF vous sera familière ; vous devez instancier des classes, définir des propriétés, appeler des méthodes et gérer des événements à l'aide du langage de programmation .NET Framework de votre choix, tel que C# ou Visual Basic.

Pour prendre en charge certaines des fonctions WPF les plus puissantes et simplifier la programmation, WPF inclut des constructions de programmation supplémentaires qui améliorent les propriétés et les événements : propriétés de dépendance et événements routés. Pour plus d'informations sur les propriétés de dépendance, consultez Vue d'ensemble des propriétés de dépendance. Pour plus d'informations sur les événements routés, consultez Vue d'ensemble des événements routés.

Balisage et code-behind

WPF offre des améliorations de programmation supplémentaires pour le développement d'applications clientes Windows. L'une des améliorations les plus évidentes est la capacité à développer une application aussi bien à l'aide du balisage que du code-behind, une expérience avec laquelle les développeurs ASP.NET sont censés être familiarisés. Généralement, on utilise le balisage XAML (Extensible Application Markup Language) pour implémenter l'apparence d'une application et les langages de programmation managés (code-behind) pour implémenter son comportement. Cette séparation de l'apparence et du comportement présente les avantages suivants :

• Les coûts de développement et de maintenance sont réduits car le balisage de l'apparence n'est pas fortement couplé avec le code du comportement.

• Le développement est plus efficace car les concepteurs peuvent implémenter l'apparence d'une application en même temps que les développeurs qui implémentent le comportement de l'application.

• De nombreux outils de conception peuvent être utilisés pour l'implémentation et le partage du balisage XAML afin de cibler les exigences des collaborateurs participant au développement des applications ; Microsoft Expression Blend fournit une expérience qui convient aux concepteurs, alors que Visual Studio 2005 cible les développeurs.

• La globalisation et la localisation des applications WPF sont considérablement simplifiées (consultez Vue d'ensemble de la globalisation et de la localisation WPF).

Les éléments suivants constituent une brève introduction au balisage et au code-behind WPF. Pour plus d'informations sur ce modèle de programmation, consultez Vue d'ensemble du langage XAML et Code-behind et XAML.

Balisage

XAML est un langage de balisage basé sur XML qui est utilisé pour implémenter l'apparence d'une application de façon déclarative. En général, il est utilisé pour créer des fenêtres, des boîtes de dialogues, des pages et des contrôles utilisateur, et pour les remplir avec des contrôles, des formes et des graphiques.

L'exemple suivant utilise XAML pour implémenter l'apparence d'une fenêtre qui contient un seul bouton.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    Title="Window with Button"
    Width="250" Height="100">

  <!-- Add button to window -->
  <Button Name="button">Click Me!</Button>

</Window>

Plus précisément, ce code XAML définit une fenêtre et un bouton à l'aide des éléments Window et Button, respectivement. Chaque élément est configuré avec des attributs, tels que l'attribut Title de l'élément Window pour spécifier le texte de la barre de titre de la fenêtre. Au moment de l'exécution, WPF convertit les éléments et les attributs définis dans le balisage en instances de classes WPF. Par exemple, l'élément Window est converti en une instance de la classe Window dont la propriété Title est la valeur de l'attribut Title.

L'illustration suivante montre l'interface utilisateur (UI) définie par XAML dans l'exemple précédent.

Pour plus d'informations, consultez Vue d'ensemble du langage XAML.

Vu que XAML est basé sur XML, l'interface utilisateur que vous composez avec est assemblée dans une hiérarchie d'éléments imbriqués, connus sous le nom d'arborescence des éléments. L'arborescence des éléments offre un moyen logique et intuitif de créer et gérer des interfaces utilisateur. Pour plus d'informations, consultez Arborescences dans WPF.

Code-behind

Le comportement principal d'une application est d'implémenter les fonctionnalités qui répondent aux interventions de l'utilisateur, y compris la gestion des événements (par exemple, un clic sur un menu, une barre d'outils ou un bouton) et, en réponse, l'appel à la logique métier et à la logique d'accès aux données. Dans WPF, ce comportement est généralement implémenté dans le code associé au balisage. Ce type de code est appelé code-behind. L'exemple suivant montre le code-behind et le balisage mis à jour par rapport à l'exemple précédent.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.AWindow"
    Title="Window with Button"
    Width="250" Height="100">

  <!-- Add button to window -->
  <Button Name="button" Click="button_Click">Click Me!</Button>

</Window>

Namespace SDKSample

    Partial Public Class AWindow
        Inherits System.Windows.Window

        Public Sub New()

            ' InitializeComponent call is required to merge the UI
            ' that is defined in markup with this class, including 
            ' setting properties and registering event handlers
            InitializeComponent()

        End Sub

        Private Sub button_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)

            ' Show message box when button is clicked
            MessageBox.Show("Hello, Windows Presentation Foundation!")

        End Sub

    End Class

End Namespace

using System.Windows; // Window, RoutedEventArgs, MessageBox

namespace SDKSample
{
    public partial class AWindow : Window
    {
        public AWindow()
        {
            // InitializeComponent call is required to merge the UI
            // that is defined in markup with this class, including 
            // setting properties and registering event handlers
            InitializeComponent();
        }

        void button_Click(object sender, RoutedEventArgs e)
        {
            // Show message box when button is clicked
            MessageBox.Show("Hello, Windows Presentation Foundation!");
        }
    }
}

Dans cet exemple, le code-behind implémente une classe qui dérive de la classe Window. L'attribut x:Class est utilisé pour associer le balisage à la classe code-behind. InitializeComponent est appelé par le constructeur de la classe code-behind pour faire fusionner l'interface utilisateur définie dans le balisage avec la classe code-behind ((InitializeComponent est généré pour vous lors de la génération de votre application, c'est pourquoi vous n'avez pas besoin de l'implémenter manuellement). La combinaison de x:Class et InitializeComponent garantit la bonne initialisation de votre implémentation chaque fois qu'elle est créée. La classe code-behind implémente également un gestionnaire d'événements pour l'événement Click du bouton. Lorsque vous cliquez sur le bouton, le gestionnaire d'événements affiche un message en appelant la méthode MessageBox.Show.

L'illustration suivante affiche le résultat obtenu lorsque vous cliquez sur le bouton.

Pour plus d'informations, consultez Code-behind et XAML.

Applications

.NET Framework, System.Windows, le balisage et le code-behind constituent la fondation du développement d'applications WPF. En outre, WPF dispose de fonctionnalités complètes pour la création d'expériences utilisateur au contenu riche. Pour regrouper ce contenu et le remettre aux utilisateurs en tant qu'« applications », WPF fournit des types et des services collectivement connus sous le nom de modèle d'application. Le modèle d'application prend en charge le développement des applications autonomes et des applications hébergées par un navigateur.

Applications autonomes

Pour les applications autonomes, vous pouvez utiliser la classe Window pour créer des fenêtres et des boîtes de dialogue accessibles depuis des barres de menus et des barres d'outils. L'illustration suivante montre une application autonome avec une fenêtre principale et une boîte de dialogue.

En outre, vous pouvez utiliser les boîtes de dialogue WPF suivantes : MessageBox, OpenFileDialog, SaveFileDialog et PrintDialog.

Pour plus d'informations, consultez Vue d'ensemble des fenêtres WPF.

Applications hébergées par un navigateur

Pour les applications hébergées par un navigateur, appelées applications du navigateur XAML (XBAP), vous pouvez créer des pages (Page) et des fonctions de page (PageFunction<T>) et naviguer entre elles à l'aide de liens hypertextes (classes Hyperlink). L'illustration suivante montre une page dans une XBAP hébergée dans Internet Explorer 7.

Les applications WPF peuvent être hébergées dans Microsoft Internet Explorer 6 et dans Internet Explorer 7. WPF offre les deux options suivantes pour les autres hôtes de navigation :

• Frame, pour héberger des îlots de contenu de navigation dans des pages ou des fenêtres.

• NavigationWindow, pour héberger du contenu de navigation dans une fenêtre entière.

Pour plus d'informations, consultez Vue d'ensemble de la navigation.

La classe d'application

Les XBAP et les applications autonomes sont souvent assez complexes et requièrent donc des services de portée application supplémentaires, y compris la gestion du démarrage et de la durée de vie et des propriétés et ressources partagées. La classe Application encapsule ces services ainsi que d'autres et peut être implémentée simplement à l'aide de XAML, comme le montre l'exemple suivant.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    StartupUri="MainWindow.xaml" />

Ce balisage est la définition d'application d'une application autonome et il demande à WPF de créer un objet Application qui ouvre automatiquement MainWindow au démarrage de l'application.

L'un des concepts clés à comprendre à propos de l'Application est que cette dernière fournit une plateforme de prise en charge commune aux applications autonomes et aux applications hébergées par un navigateur. Par exemple, le code XAML précédent pourrait être utilisé par une application hébergée par un navigateur pour la navigation automatique vers une page lorsqu'une XBAP est lancée, comme le montre l'exemple suivant.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    StartupUri="HomePage.xaml" />

Pour plus d'informations, consultez Vue d'ensemble de la gestion d'applications.

Sécurité

Étant donné que les XBAP sont hébergées dans un navigateur, la sécurité est importante. En particulier, les XBAP utilisent un bac à sable (sandbox) de sécurité de confiance partielle pour appliquer des restrictions inférieures ou égales aux restrictions imposées aux applications HTML. En outre, chaque fonctionnalité HTML pouvant être exécutée en confiance partielle depuis des XBAP a été testée avec un processus de sécurité complet, détaillé dans Stratégie de sécurité de Windows Presentation Foundation – ingénierie de sécurité.

Cependant, la majorité des fonctionnalités WPF peuvent être exécutées en toute sécurité depuis des XBAP, comme décrit dans Sécurité de confiance partielle de Windows Presentation Foundation.

Contrôles

Les expériences utilisateur fournies par le modèle d'application sont des contrôles construits. Dans WPF, « contrôle » est un terme général qui s'applique à une catégorie de classes WPF qui sont hébergées dans une fenêtre ou une page, qui ont une interface utilisateur (UI) et qui implémentent un certain comportement.

Pour plus d'informations, consultez Vue d'ensemble des contrôles. Pour obtenir des exemples d'introduction, consultez Exemples de la bibliothèque de contrôles.

Appel du contrôle WPF

Les contrôles WPF intégrés sont répertoriés ici.

• Boutons : Button et RepeatButton.

• Boîtes de dialogue : OpenFileDialog, PrintDialog et SaveFileDialog.

• Encre numérique : InkCanvas et InkPresenter.

• Documents : DocumentViewer, FlowDocumentPageViewer, FlowDocumentReader, FlowDocumentScrollViewer et StickyNoteControl.

• Entrée : TextBox, RichTextBox et PasswordBox.

• Disposition : Border, BulletDecorator, Canvas, DockPanel, Expander, Grid, GridView, GridSplitter, GroupBox, Panel, ResizeGrip, Separator, ScrollBar, ScrollViewer, StackPanel, Thumb, Viewbox, VirtualizingStackPanel, Window et WrapPanel.

• Médias : Image, MediaElement et SoundPlayerAction.

• Menus : ContextMenu, Menu et ToolBar.

• Navigation : Frame, Hyperlink, Page, NavigationWindow et TabControl.

• Sélection : CheckBox, ComboBox, ListBox, TreeView, RadioButton et Slider.

• Informations utilisateur : AccessText, Label, Popup, ProgressBar, StatusBar, TextBlock et ToolTip.

Entrée et commande

Les contrôles détectent et répondent souvent à l'entrée utilisateur. Le système d'entrée WPF utilise des événements directs et routés pour prendre en charge la saisie de texte, la gestion du focus et la position de la souris. Pour plus d'informations, consultez Vue d'ensemble des entrées.

Les applications ont souvent des spécifications d'entrée complexes. WPF fournit un système de commande qui sépare les actions d'entrée utilisateur du code qui répond à ces actions. Pour plus d'informations, consultez Vue d'ensemble des commandes.

Disposition

Lorsque vous créez une interface utilisateur, réorganisez vos contrôles par emplacement et par taille pour former une disposition. L'une des spécifications clés de toute disposition est de s'adapter aux modifications de la taille de la fenêtre et des paramètres d'affichage. Plutôt que de vous forcer à écrire le code pour vous adapter à une disposition, WPF vous fournit un système de disposition extensible de première classe.

Le positionnement relatif est l'élément essentiel du système de disposition. Il augmente la capacité d'adaptation aux modifications des conditions d'affichage et de disposition des fenêtres. De plus, le système de disposition gère la négociation entre les contrôles pour déterminer la disposition. La négociation est un processus qui s'effectue en deux étapes : premièrement, un contrôle informe son parent de l'emplacement et de la taille dont il a besoin ; deuxièmement, le parent informe le contrôle de l'espace dont il peut disposer.

Le système de disposition est exposé aux contrôles enfants via des classes WPF de base. Pour les dispositions courantes telles que les grilles, l'empilement et l'ancrage, WPF inclut plusieurs contrôles de disposition :

• Canvas : les contrôles enfants fournissent leur propre disposition.

• DockPanel : les contrôles enfants sont alignés aux bords du panneau.

• Grid : les contrôles enfants sont positionnés en lignes et en colonnes.

• StackPanel : les contrôles enfants sont empilés verticalement ou horizontalement.

• VirtualizingStackPanel : les contrôles enfants sont virtualisés et réorganisés sur une seule ligne, verticale ou horizontale.

• WrapPanel : les contrôles enfants sont positionnés de gauche à droite et renvoyés à la ligne suivante lorsqu'il y a plus de contrôles sur la ligne en cours que l'espace ne l'autorise.

L'exemple suivant utilise un DockPanel pour disposer plusieurs contrôles TextBox.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.LayoutWindow"
    Title="Layout with the DockPanel" Height="143" Width="319">

  <!--DockPanel to layout four text boxes--> 
  <DockPanel>
    <TextBox DockPanel.Dock="Top">Dock = "Top"</TextBox>
    <TextBox DockPanel.Dock="Bottom">Dock = "Bottom"</TextBox>
    <TextBox DockPanel.Dock="Left">Dock = "Left"</TextBox>
    <TextBox Background="White">This TextBox "fills" the remaining space.</TextBox>
  </DockPanel>

</Window>

Le DockPanel autorise les contrôles TextBox enfants à lui dire comment les réorganiser. Pour cela, le DockPanel implémente une propriété Dock exposée aux contrôles enfants pour permettre à chacun d'eux de spécifier un style d'ancrage.

Remarque :
Une propriété implémentée par un contrôle parent pour une utilisation par des contrôles enfants est une construction WPF appelée propriété attachée (consultez Vue d'ensemble des propriétés attachées).

L'illustration suivante affiche le résultat du balisage XAML dans l'exemple précédent.

Pour plus d'informations, consultez Système de disposition. Pour obtenir un exemple d'introduction, consultez Galerie de dispositions WPF, exemple.

Liaison de données

La plupart des applications sont créées pour permettre aux utilisateurs d'afficher et de modifier des données. Pour les applications WPF, le travail de stockage et d'accès aux données est déjà fourni par des technologies telles que Microsoft SQL Server et ADO.NET. Après avoir accédé aux données et les avoir chargées dans les objets managés d'une application, les difficultés commencent pour les applications WPF. Cela implique essentiellement deux opérations :

1. La copie des données depuis les objets managés vers des contrôles, où les données pourront être affichées et modifiées.

2. La garantie que les modifications apportées aux données à l'aide des contrôles sont recopiées vers les objets managés.

Pour simplifier le développement d'applications, WPF fournit un moteur de liaison de données qui exécute ces étapes automatiquement. La principale unité du moteur de liaison de données est la classe Binding, dont le travail est de lier un contrôle (la cible de liaison) à un objet de données (la source de liaison). Cette relation est illustrée ci-dessous.

L'exemple suivant montre comment lier une TextBox à une instance d'un objet Person personnalisé. Le code suivant montre l'implémentation Person.

Namespace SDKSample

    Class Person

        Private _name As String = "No Name"

        Public Property Name() As String
            Get
                Return _name
            End Get
            Set(ByVal value As String)
                _name = value
            End Set
        End Property

    End Class

End Namespace

namespace SDKSample
{
    class Person
    {
        string name = "No Name";

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }
}

Le balisage suivant lie la TextBox à une instance d'un objet Person personnalisé.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.DataBindingWindow">


...


<!-- Bind the TextBox to the data source (TextBox.Text to Person.Name) -->
<TextBox Name="personNameTextBox" Text="{Binding Path=Name}" />


...


</Window>

Imports System.Windows ' Window

Namespace SDKSample

    Partial Public Class DataBindingWindow
        Inherits Window

        Public Sub New()
            InitializeComponent()

            ' Create Person data source
            Dim person As Person = New Person()

            ' Make data source available for binding
            Me.DataContext = person

        End Sub

    End Class

End Namespace

using System.Windows; // Window

namespace SDKSample
{
    public partial class DataBindingWindow : Window
    {
        public DataBindingWindow()
        {
            InitializeComponent();

            // Create Person data source
            Person person = new Person();

            // Make data source available for binding
            this.DataContext = person;
        }
    }
}

Dans cet exemple, la classe Person est instanciée en code-behind et définie comme contexte de données de DataBindingWindow. Dans le balisage, la propriété Text de la TextBox est liée à la propriété Person.Name (à l'aide de la syntaxe XAML "{Binding ... }"). Ce code XAML demande à WPF de lier le contrôle TextBox à l'objet Person stocké dans la propriété DataContext de la fenêtre.

Le moteur de liaison de données WPF fournit une prise en charge supplémentaire qui inclut la validation, le tri, le filtrage et le regroupement. En outre, la liaison de données prend en charge l'utilisation de modèles de données afin de créer une interface utilisateur personnalisée pour les données liées lorsque l'interface utilisateur affichée par les contrôles WPF standard n'est pas appropriée.

Pour plus d'informations, consultez Vue d'ensemble de la liaison de données. Pour obtenir un exemple d'introduction, consultez Liaison de données, démonstration.

Graphiques

WPF présente un jeu de fonctionnalités graphiques étendu, évolutif et flexible possédant les avantages suivants :

• Graphiques indépendants du périphérique et de toute résolution. L'unité de mesure de base du système graphique WPF est le pixel indépendant du périphérique, soit 1/96e d'un pouce, quelle que soit la résolution réelle de l'écran. Elle sert de base au rendu indépendant du périphérique et de toute résolution. Chaque pixel indépendant du périphérique est automatiquement mis à l'échelle pour correspondre au paramètre de points par pouce (ppp) du système de restitution.

• Précision améliorée. Le système de coordonnées WPF est mesuré avec des nombres à virgule flottante double précision plutôt que simple précision. Les transformations et valeurs d'opacité sont également exprimées en double précision. WPF prend également en charge une large gamme de couleurs (scRGB) et fournit une prise en charge intégrée pour la gestion des entrées provenant d'espaces de couleur différents.

• Graphiques avancés et prise en charge de l'animation. WPF simplifie la programmation graphique en gérant les scènes d'animation à votre place ; ainsi, vous n'avez pas besoin de vous préoccuper du traitement des scènes, du rendu des boucles ou de l'interpolation bilinéaire. En outre, WPF fournit une prise en charge du test de recherche et une prise en charge complète de la composition alpha.

• Accélération matérielle. Le système graphique WPF profite du matériel vidéo pour réduire l'utilisation du processeur.

Formes 2D

WPF fournit une bibliothèque de formes vectorielles courantes 2D, telles que les rectangles et ellipses présentés dans l'illustration suivante.

Les formes ont notamment pour intérêt de ne pas servir uniquement à l'affichage ; les formes implémentent la majorité des fonctionnalités que vous attendez des contrôles, y compris l'entrée au clavier et à la souris. L'exemple suivant montre l'événement MouseUp d'une Ellipse gérée.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.EllipseEventHandlingWindow"
    Title="Click the Ellipse">
    <Ellipse Name="clickableEllipse" Fill="Blue" MouseUp="clickableEllipse_MouseUp" />
</Window>

Imports System.Windows ' Window, MessageBox
Imports System.Windows.Input ' MouseButtonEventArgs

Namespace SDKSample

    Public Class EllipseEventHandlingWindow
        Inherits Window

        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub clickableEllipse_MouseUp(ByVal sender As Object, ByVal e As MouseButtonEventArgs)
            MessageBox.Show("You clicked the ellipse!")
        End Sub

    End Class

End Namespace

using System.Windows; // Window, MessageBox
using System.Windows.Input; // MouseButtonEventHandler

namespace SDKSample
{
    public partial class EllipseEventHandlingWindow : Window
    {
        public EllipseEventHandlingWindow()
        {
            InitializeComponent();
        }

        void clickableEllipse_MouseUp(object sender, MouseButtonEventArgs e)
        {
            // Display a message
            MessageBox.Show("You clicked the ellipse!");
        }
    }
}

L'illustration suivante montre ce qui est produit par le code précédent.

Pour plus d'informations, consultez Vue d'ensemble des formes et dessins de base dans WPF. Pour obtenir un exemple d'introduction, consultez Éléments de forme, exemple.

Géométries 2D

Les formes 2D fournies par WPF couvrent le jeu standard des formes de base. Toutefois, vous pourriez avoir besoin de créer des formes personnalisées afin de faciliter la conception d'une interface utilisateur personnalisée. Pour cela, WPF fournit des géométries. L'illustration suivante montre l'utilisation de géométries pour créer une forme personnalisée qui peut être dessinée directement, utilisée comme pinceau ou pour découper d'autres formes et contrôles.

Les objets Path peuvent être utilisés pour dessiner des formes fermées ou ouvertes, plusieurs formes et même des formes courbées.

Les objets Geometry peuvent être utilisés pour le découpage, les tests de recherche et le rendu de données graphiques 2D.

Pour plus d'informations, consultez Vue d'ensemble de Geometry. Pour obtenir un exemple d'introduction, consultez Géométries, exemple.

Effets 2D

Un sous-ensemble de fonctions 2DWPF inclut des effets visuels tels que des dégradés, des bitmaps, des dessins, la peinture avec des vidéos, la rotation, la mise à l'échelle et l'inclinaison. Ces derniers sont tous réalisés avec des pinceaux ; l'illustration suivante montre quelques exemples.

Pour plus d'informations, consultez Vue d'ensemble des pinceaux WPF. Pour obtenir un exemple d'introduction, consultez Pinceaux, exemple.

Rendu 3D

WPF inclut également des fonctions de rendu 3D qui s'intègrent avec les graphiques 2D pour permettre la création d'interfaces utilisateur plus attrayantes et intéressantes. Par exemple, l'illustration suivante montre des images 2D restituées sur des formes 3D.

Pour plus d'informations, consultez Vue d'ensemble des graphiques 3D. Pour obtenir un exemple d'introduction, consultez Solides 3D, exemple.

Animation

La prise en charge d'animations WPF vous permet d'agrandir, de faire bouger, de faire pivoter et de réaliser des fondus avec les contrôles pour créer des transitions de page intéressantes, et plus encore. Vous pouvez animer la plupart des classes WPF, même les classes personnalisées. L'illustration suivante montre une animation simple en action.

Pour plus d'informations, consultez Vue d'ensemble de l'animation. Pour obtenir un exemple d'introduction, consultez Galerie d'exemples d'animation.

Médias

L'un des moyens d'acheminer un contenu riche est d'utiliser des médias audiovisuels. WPF fournit une prise en charge spéciale pour les images, les vidéos et l'audio.

Images

Les images sont communes à la plupart des applications et WPF fournit plusieurs façons de les utiliser. L'illustration suivante montre une interface utilisateur avec une zone de liste qui contient des images miniatures. Lorsque vous sélectionnez une miniature, l'image s'affiche en grand.

Pour plus d'informations, consultez Vue d'ensemble de l'acquisition d'images. Pour obtenir un exemple d'introduction, consultez WPF Photo Viewer, démonstration.

Audio et vidéo

Le contrôle MediaElement peut lire des vidéos et de l'audio et est assez flexible pour servir de base à un lecteur multimédia personnalisé. Le balisage XAML suivant implémente un lecteur multimédia.

<MediaElement 
  Name="myMediaElement" 
  Source="media/wpf.wmv" 
  LoadedBehavior="Manual" 
  Width="350" Height="250" />

La fenêtre de l'illustration suivante montre le contrôle MediaElement en action.

Pour plus d'informations, consultez Vue d'ensemble des graphiques, animations et du multimédia WPF. Pour obtenir un exemple d'introduction, consultez Galerie multimédia.

Texte et typographie

Pour faciliter un rendu de texte de qualité optimale, WPF offre les fonctionnalités suivantes :

• Prise en charge de la police OpenType.

• Améliorations ClearType.

• Performances élevées tirant parti de l'accélération matérielle.

• Intégration de texte avec des médias, des graphiques et des animations.

• Prise en charge de polices internationales et de mécanismes de secours.

Comme démonstration d'une intégration de texte avec des graphiques, l'illustration suivante montre l'application d'un ornement de texte.

Pour plus d'informations, consultez Typographie dans Windows Presentation Foundation. Pour obtenir des exemples d'introduction, consultez Exemples de typographies.

Documents

WPF dispose d'une prise en charge native pour utiliser trois types de documents : les documents dynamiques, les documents fixes et les documents XML Paper Specification (XPS). WPF fournit également les services nécessaires pour créer, afficher, gérer, annoter, empaqueter et imprimer des documents.

Documents dynamiques

Les documents dynamiques sont conçus pour optimiser l'affichage et la lisibilité en ajustant et en refluant dynamiquement le contenu lorsque la taille de la fenêtre et les paramètres d'affichage sont modifiés. Le balisage XAML suivant montre la définition d'un FlowDocument.

<FlowDocument xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation">

  <Paragraph FontSize="18" FontWeight="Bold">Flow Document</Paragraph>

  <Paragraph>
    Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy
    nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi
    enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis
    nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure.
  </Paragraph>


...


</FlowDocument>

L'exemple suivant montre comment charger un document dynamique dans un FlowDocumentReader pour l'affichage, la recherche et l'impression.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.FlowDocumentReaderWindow"
    Title="Flow Document Reader">
  <FlowDocumentReader Name="flowDocumentReader" />
</Window>

Imports System.Windows 'Window
Imports System.Windows.Documents 'FlowDocument
Imports System.IO 'FileStream, FileMode
Imports System.Windows.Markup 'XamlReader

Namespace SDKSample

    Public Class FlowDocumentReaderWindow
        Inherits Window

        Public Sub New()
            Me.InitializeComponent()
            Using stream1 As FileStream = New FileStream("AFlowDocument.xaml", _
                FileMode.Open, FileAccess.Read)
                Dim document1 As FlowDocument = _
                    TryCast(XamlReader.Load(stream1), FlowDocument)
                Me.flowDocumentReader.Document = document1
            End Using
        End Sub

    End Class

End Namespace

using System.Windows; // Window
using System.Windows.Documents; // FlowDocument
using System.IO; // FileStream, FileMode
using System.Windows.Markup; // XamlReader

namespace SDKSample
{
    public partial class FlowDocumentReaderWindow : System.Windows.Window
    {
        public FlowDocumentReaderWindow()
        {
            InitializeComponent();

            // Open the file that contains the FlowDocument
            using (FileStream xamlFile = new FileStream("AFlowDocument.xaml", 
                FileMode.Open, FileAccess.Read))
            {
                // Parse the file with the XamlReader.Load method
                FlowDocument content = XamlReader.Load(xamlFile) as FlowDocument;

                // Set the Document property to the parsed FlowDocument object
                this.flowDocumentReader.Document = content;
            }
        }
    }
}

L'exemple suivant affiche le résultat.

Pour plus d'informations, consultez Vue d'ensemble des documents dynamiques. Pour obtenir un exemple d'introduction, consultez Propriétés FlowDocument, exemple.

Documents fixes

Les documents fixes sont prévus pour les applications qui requièrent une présentation WYSIWYG (« tel affichage, tel résultat ») précise, particulièrement en ce qui concerne l'impression. Les documents fixes sont principalement utilisés pour la Publication Assistée par Ordinateur (PAO),le traitement de texte et la présentation d'un formulaire, où le respect de la conception de la page d'origine est essentiel.

Les documents fixes conservent l'organisation précise de leur contenu indépendamment du périphérique. Par exemple, un document fixe affiché en 96 points par pouce (ppp) apparaît de la même manière que lorsqu'il est imprimé sur une imprimante laser 600 ppp ou une photocomposeuse 4800 ppp. Dans tous les cas, la disposition reste la même, bien que la qualité du document varie selon les fonctions de chaque périphérique.

Pour plus d'informations, consultez Documents dans Windows Presentation Foundation.

Documents XPS

Les documents XML Paper Specification (XPS) reposent sur des documents fixes WPF. Les documents XPS sont décrits avec un schéma XML, qui est essentiellement une représentation paginée du support électronique. XPS est un format de document ouvert et multiplateforme conçu pour faciliter la création, le partage, l'impression et l'archivage de documents paginés. Les principales fonctionnalités de la technologie XPS incluent les éléments suivants :

• Empaquetage de documents XPS comme fichiers ZipPackage conformes aux Open Packaging Conventions (OPC).

• Hébergement dans des applications autonomes et dans des applications basées sur un navigateur.

• Génération manuelle et manipulation de documents XPS depuis des applications WPF.

• Rendu haute-fidélité en ciblant une qualité optimale du périphérique de sortie.

• Impression Windows Vista en attente.

• Routage direct de documents vers des imprimantes compatibles avec le format XPS.

• Intégration de l'interface utilisateur avec DocumentViewer.

L'illustration suivante montre un document XPS affiché par une DocumentViewer.

DocumentViewer permet également aux utilisateurs de modifier l'affichage, la recherche et l'impression de documents XPS.

Pour plus d'informations, consultez Documents dans Windows Presentation Foundation. Pour obtenir un exemple d'introduction, consultez Création d'un document XPS, exemple.

Annotations

Les annotations sont des remarques ou des commentaires ajoutés à des documents pour signaler des informations ou mettre en évidence des éléments intéressants afin de s'y référer ultérieurement. Bien qu'il soit facile d'écrire des remarques sur des documents imprimés, la capacité d'en « écrire » sur des documents électroniques est souvent limitée ou non disponible. Toutefois, WPF fournit un système d'annotations qui prend en charge les pense-bêtes et les mises en évidence. En outre, ces annotations peuvent être appliquées aux documents hébergés dans le contrôle DocumentViewer, comme indiqué dans l'illustration suivante.

Pour plus d'informations, consultez Vue d'ensemble des annotations. Pour obtenir un exemple d'introduction, consultez Sérialisation de documents, exemple.

Empaquetage

Les APISystem.IO.PackagingWPF permettent à vos applications d'organiser des données, du contenu et des ressources dans des documents compressés uniques, portables, faciles à distribuer et faciles d'accès. Il est également possible d'inclure des signatures numériques pour authentifier des éléments contenus dans un package et pour vérifier que l'élément signé n'a pas été falsifié ou modifié. Vous pouvez également chiffrer des packages à l'aide de la gestion des droits afin de restreindre l'accès aux informations protégées.

Pour plus d'informations, consultez Documents dans Windows Presentation Foundation. Pour obtenir des exemples, consultez Exemples d'empaquetage.

Impression

.NET Framework inclut un sous-système d'impression augmenté par WPF avec une prise en charge pour un contrôle amélioré du système d'impression. Les améliorations de l'impression incluent les éléments suivants :

• Installation en temps réel de serveurs d'impression et de files d'attente distants.

• Découverte dynamique des fonctions de l'imprimante.

• Définition dynamique des options de l'imprimante.

• Redirection et priorité du travail d'impression.

Les documents XPS disposent également d'une amélioration clé des performances. En général, le chemin d'accès d'impression interface graphique GDI (Graphics Device Interface) Microsoft Windows existant requiert deux conversions :

• La première est la conversion d'un document au format du processeur d'impression, tel que métafichier amélioré (EMF, Enhanced Metafile).

• La deuxième est une conversion dans le langage de description de page de l'imprimante, tel que le langage PCL (Printer Control Language) ou PostScript.

Toutefois, les documents XPS évitent ces conversions car l'un des composants du format de fichier XPS est un langage de processeur d'impression et un langage de description de page. Cette prise en charge permet de réduire la taille des fichiers en attente et les chargements de l'imprimante du réseau.

Pour plus d'informations, consultez Vue d'ensemble de l'impression. Pour obtenir un exemple d'introduction, consultez Impression d'un document XPS.

Personnalisation des applications WPF

Jusqu'à présent, vous avez vu les principaux blocs de construction de WPF pour le développement des applications. Vous utilisez le modèle d'application pour héberger et transmettre le contenu de l'application, principalement composé de contrôles. Pour simplifier l'organisation des contrôles dans une interface utilisateur et garantir la conservation de cette organisation face aux modifications de la taille de la fenêtre et des paramètres d'affichage, vous utilisez le système de disposition WPF. Étant donné que la plupart des applications permettent aux utilisateurs d'interagir avec des données, utilisez la liaison de données pour réduire le travail d'intégration de votre interface utilisateur avec les données. Pour améliorer l'apparence visuelle de votre application, utilisez la plage complète de graphiques, d'animations et de médias fournie par WPF. Enfin, si votre application fonctionne avec du texte et des documents, vous pouvez utiliser les fonctions de texte, de typographie, de document, d'annotation, d'empaquetage et d'impression de WPF.

Les concepts de base ne sont pourtant pas tout le temps suffisants pour créer et gérer une expérience utilisateur vraiment particulière et visuellement surprenante. Il est possible que les contrôles WPF standard ne puissent pas s'intégrer avec l'apparence souhaitée de votre application. Les données risquent de ne pas s'afficher de la manière la plus efficace. L'expérience utilisateur globale de votre application peut ne pas être adaptée à l'apparence par défaut des thèmes Windows. À bien des égards, une technologie de présentation a autant besoin d'une extensibilité visuelle que de tout autre type d'extensibilité.

C'est pourquoi WPF fournit différents mécanismes pour créer des expériences utilisateur uniques, y compris un modèle de contenu riche pour les contrôles, les déclencheurs, les modèles de contrôles et de données, les styles, les ressources d'interface utilisateur, les thèmes et les apparences.

Modèle de contenu

L'objectif principal d'une majorité des contrôles WPF est d'afficher du contenu. Dans WPF, le type et le nombre d'éléments qui peuvent constituer le contenu d'un contrôle sont appelés modèle de contenu du contrôle. Certains contrôles peuvent contenir un seul élément et un seul type de contenu ; par exemple, le contenu d'une TextBox est une valeur de chaîne assignée à la propriété Text. L'exemple suivant définit le contenu d'une TextBox.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.TextBoxContentWindow"
    Title="TextBox Content">


...


<TextBox Text="This is the content of a TextBox." />


...


</Window>

L'illustration suivante affiche le résultat.

Toutefois, d'autres contrôles peuvent contenir plusieurs éléments de différents types de contenu ; le contenu d'un Button, spécifié par la propriété Content, peut contenir différents éléments, y compris des contrôles de disposition, du texte, des images et des formes. L'exemple suivant montre un Button avec du contenu qui inclut un DockPanel, une Label, une Border et un MediaElement.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.ButtonContentWindow"
    Title="Button Content">


...


<Button Margin="20">
  <!-- Button Content -->
  <DockPanel Width="200" Height="180">
    <Label DockPanel.Dock="Top" HorizontalAlignment="Center">Click Me!</Label>
    <Border Background="Black" BorderBrush="Yellow" BorderThickness="2" 
      CornerRadius="2" Margin="5">
      <MediaElement Source="media/wpf.wmv" Stretch="Fill" />
    </Border>
  </DockPanel>
</Button>


...


</Window>

L'illustration suivante montre le contenu de ce bouton.

Pour plus d'informations sur les types de contenu pris en charge par différents contrôles, consultez Modèle de contenu WPF.

Déclencheurs

Bien que l'objectif principal du balisage XAML soit d'implémenter l'apparence d'une application, vous pouvez également utiliser XAML pour implémenter certains aspects du comportement d'une application. Vous pouvez, par exemple, utiliser des déclencheurs pour modifier l'apparence d'une application à partir des interventions de l'utilisateur. Pour plus d'informations, consultez « Déclencheurs » dans Application d'un style et création de modèles.

Modèles de contrôle

Les interfaces utilisateur par défaut pour les contrôles WPF sont en général construites à partir d'autres formes et contrôles. Par exemple, un Button est composé de contrôles ButtonChrome et ContentPresenter. Le ButtonChrome fournit l'apparence du bouton standard, alors que le ContentPresenter affiche le contenu du bouton, comme spécifié par la propriété Content.

Parfois, l'apparence par défaut d'un contrôle peut être incompatible avec l'apparence globale d'une application. Dans ce cas, vous pouvez utiliser un ControlTemplate pour modifier l'apparence de l'interface utilisateur du contrôle sans modifier ni son contenu, ni son comportement.

L'exemple suivant indique comment modifier l'apparence d'un Button à l'aide d'un ControlTemplate.

<Window 
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.ControlTemplateButtonWindow"
  Title="Button with Control Template" Height="158" Width="290">

  <!-- Button using an ellipse -->
  <Button Content="Click Me!" Click="button_Click">
    <Button.Template>
      <ControlTemplate TargetType="{x:Type Button}">
        <Grid Margin="5">
          <Ellipse Stroke="DarkBlue" StrokeThickness="2">
            <Ellipse.Fill>
              <RadialGradientBrush Center="0.3,0.2" RadiusX="0.5" RadiusY="0.5">
                <GradientStop Color="Azure" Offset="0.1" />
                <GradientStop Color="CornflowerBlue" Offset="1.1" />
              </RadialGradientBrush>
            </Ellipse.Fill>
          </Ellipse>
          <ContentPresenter Name="content" HorizontalAlignment="Center" 
            VerticalAlignment="Center"/>
        </Grid>
      </ControlTemplate>
    </Button.Template>

  </Button>

</Window>

Imports System.Windows ' Window, RoutedEventArgs, MessageBox

Namespace SDKSample

    Public Class ControlTemplateButtonWindow
        Inherits Window

        Public Sub New()

            InitializeComponent()

        End Sub

        Private Sub button_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            MessageBox.Show("Hello, Windows Presentation Foundation!")
        End Sub

    End Class

End Namespace

using System.Windows; // Window, RoutedEventArgs, MessageBox

namespace SDKSample
{
    public partial class ControlTemplateButtonWindow : Window
    {
        public ControlTemplateButtonWindow()
        {
            InitializeComponent();
        }

        void button_Click(object sender, RoutedEventArgs e)
        {
            // Show message box when button is clicked
            MessageBox.Show("Hello, Windows Presentation Foundation!");
        }
    }
}

Dans cet exemple, l'interface utilisateur du bouton par défaut a été remplacée par une Ellipse aux bords bleu foncé remplie à l'aide d'un RadialGradientBrush. Le contrôle ContentPresenter affiche le contenu du Button « Cliquez sur moi ! ». Lorsque vous cliquez sur le Button, l'événement Click est déclenché dans le cadre du comportement par défaut du contrôle Button. Le résultat est affiché dans l'illustration suivante.

Pour plus d'informations, consultez ControlTemplate. Pour obtenir un exemple d'introduction, consultez Style avec ControlTemplates, exemple.

Modèles de données

Alors qu'un modèle de contrôle vous permet de spécifier l'apparence d'un contrôle, un modèle de données vous permet de spécifier l'apparence du contenu d'un contrôle. Les modèles de données sont souvent utilisés pour améliorer l'affichage des données liées. L'illustration suivante montre l'apparence par défaut d'une ListBox liée à une collection d'objets Task, où chaque tâche a un nom, une description et une priorité.

L'apparence par défaut correspond à ce que vous pourriez attendre d'une ListBox. Toutefois, l'apparence par défaut de chaque tâche ne contient que le nom de la tâche. Pour afficher le nom, la description et la priorité de la tâche, l'apparence par défaut des éléments de liste liés du contrôle ListBox doit être modifiée à l'aide d'un DataTemplate. Le code XAML suivant définit ce type de DataTemplate appliqué à chaque tâche à l'aide de l'attribut ItemTemplate.

<Window
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.DataTemplateWindow"
  Title="With a Data Template">


...


<!-- Data Template (applied to each bound task item in the task collection) -->
<DataTemplate x:Key="myTaskTemplate">
  <Border Name="border" BorderBrush="DarkSlateBlue" BorderThickness="2" 
    CornerRadius="2" Padding="5" Margin="5">
    <Grid>
      <Grid.RowDefinitions>
        <RowDefinition/>
        <RowDefinition/>
        <RowDefinition/>
      </Grid.RowDefinitions>
      <Grid.ColumnDefinitions>
        <ColumnDefinition Width="Auto" />
        <ColumnDefinition />
      </Grid.ColumnDefinitions>
      <TextBlock Grid.Row="0" Grid.Column="0" Padding="0,0,5,0" Text="Task Name:"/>
      <TextBlock Grid.Row="0" Grid.Column="1" Text="{Binding Path=TaskName}"/>
      <TextBlock Grid.Row="1" Grid.Column="0" Padding="0,0,5,0" Text="Description:"/>
      <TextBlock Grid.Row="1" Grid.Column="1" Text="{Binding Path=Description}"/>
      <TextBlock Grid.Row="2" Grid.Column="0" Padding="0,0,5,0" Text="Priority:"/>
      <TextBlock Grid.Row="2" Grid.Column="1" Text="{Binding Path=Priority}"/>
    </Grid>
  </Border>  
</DataTemplate>


...


<!-- Data template is specified by the ItemTemplate attribute -->
<ListBox 
  ItemsSource="{Binding}" 
  ItemTemplate="{StaticResource myTaskTemplate}" 
  HorizontalContentAlignment="Stretch" 
  IsSynchronizedWithCurrentItem="True" 
  Margin="5,0,5,5" />


...


</Window>

L'illustration suivante montre l'effet de ce code.

Notez que la ListBox a conservé son comportement et son apparence globale ; seule l'apparence du contenu affiché par la zone de liste a été modifiée.

Pour plus d'informations, consultez Vue d'ensemble des modèles de données. Pour obtenir un exemple d'introduction, consultez Introduction aux modèles de données, exemple.

Styles

Les styles permettent aux développeurs et aux concepteurs de choisir l'apparence standard qu'ils utiliseront pour leur produit. WPF fournit un modèle de style fort, dont la fondation est l'élément Style. L'exemple suivant crée un style qui définit la couleur d'arrière-plan Orange pour tous les éléments Button d'une fenêtre.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.StyleWindow"
    Title="Styles">


...


<!-- Style that will be applied to all buttons -->
<Style TargetType="{x:Type Button}">
  <Setter Property="Background" Value="Orange" />
  <Setter Property="BorderBrush" Value="Crimson" />
  <Setter Property="FontSize" Value="20" />
  <Setter Property="FontWeight" Value="Bold" />
  <Setter Property="Margin" Value="5" />
</Style>


...


<!-- This button will have the style applied to it -->
<Button>Click Me!</Button>

<!-- This labe will not have the style applied to it -->
<Label>Don't Click Me!</Label>

<!-- This button will have the style applied to it -->
<Button>Click Me!</Button>


...


</Window>

Étant donné que ce style cible tous les contrôles Button, le style est automatiquement appliqué à tous les boutons de la fenêtre, comme indiqué dans l'illustration suivante.

Pour plus d'informations, consultez Application d'un style et création de modèles. Pour obtenir un exemple d'introduction, consultez Introduction aux styles et aux modèles, exemple.

Ressources

Les contrôles d'une application doivent partager la même apparence, ce qui peut tout inclure, depuis les polices et les couleurs d'arrière-plan jusqu'aux modèles de contrôle, modèles de données et styles. Vous pouvez utiliser la prise en charge de WPF pour les ressources d'interface utilisateur (UI) afin d'encapsuler ces ressources dans un emplacement unique en vue d'une réutilisation.

L'exemple suivant définit une couleur d'arrière-plan commune partagée par un Button et une Label.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.ResourcesWindow"
    Title="Resources Window">

  <!-- Define window-scoped background color resource -->
  <Window.Resources>
    <SolidColorBrush x:Key="defaultBackground" Color="Red" />
  </Window.Resources>


...


<!-- Button background is defined by window-scoped resource -->
<Button Background="{StaticResource defaultBackground}">One Button</Button>

<!-- Label background is defined by window-scoped resource -->
<Label Background="{StaticResource defaultBackground}">One Label</Label>


...


</Window>

Cet exemple implémente une ressource de couleur d'arrière-plan à l'aide de l'élément de propriété Window.Resources. Cette ressource est disponible pour tous les enfants de la Window. Il existe différentes portées de ressource, dont les suivantes, répertoriées dans l'ordre dans lequel elles sont résolues :

1. Un contrôle individuel (à l'aide de la propriété FrameworkElement.Resources héritée).

2. Une Window ou une Page (également à l'aide de la propriété FrameworkElement.Resources héritée).

3. Une Application (à l'aide de la propriété Application.Resources).

Les diverses portées offrent une grande flexibilité en ce qui concerne la manière de définir et partager vos ressources.

Au lieu d'associer directement vos ressources à une portée précise, vous pouvez empaqueter une ou plusieurs ressources à l'aide d'un ResourceDictionary séparé qui peut être référencé dans d'autres parties d'une application. L'exemple suivant définit une couleur d'arrière-plan par défaut dans un dictionnaire de ressources.

<ResourceDictionary 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml">

  <!-- Define background color resource -->
  <SolidColorBrush x:Key="defaultBackground" Color="Red" />

  <!-- Define other resources -->


...


</ResourceDictionary>

L'exemple suivant référence le dictionnaire de ressources défini dans l'exemple précédent afin qu'il soit partagé dans une application.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App">

  <Application.Resources>
    <ResourceDictionary>
      <ResourceDictionary.MergedDictionaries>
        <ResourceDictionary Source="BackgroundColorResources.xaml"/>
      </ResourceDictionary.MergedDictionaries>
    </ResourceDictionary>
  </Application.Resources>


...


</Application>

Les ressources et les dictionnaires de ressources constituent la fondation de la prise en charge WPF pour les thèmes et les apparences.

Pour plus d'informations, consultez Vue d'ensemble des ressources. Pour obtenir un exemple d'introduction, consultez Ressources d'applications, exemple.

Thèmes et apparences

D'un point de vue visuel, un thème définit l'apparence globale de Windows et les applications qui s'y exécutent. Windows est fourni avec plusieurs thèmes. Par exemple, Microsoft Windows XP est fourni avec les thèmes Windows XP et Windows classiques, alors que Windows Vista est fourni avec les thèmes Windows Vista et Windows classiques. L'apparence définie par un thème définit l'apparence par défaut d'une application WPF. Toutefois, WPF ne s'intègre pas directement avec les thèmes Windows. Dans la mesure où l'apparence de WPF est définie par des modèles, WPF inclut un modèle pour chacun des thèmes Windows connus, notamment Aero (Windows Vista), Classic (Microsoft Windows 2000), Luna (Microsoft Windows XP) et Royale (Microsoft Windows XP Édition Media Center 2005). Ces thèmes sont empaquetés sous forme de dictionnaires de ressources résolus si les ressources sont introuvables dans l'application. De nombreuses applications se servent de ces thèmes pour définir leur apparence visuelle ; la cohérence avec l'apparence Windows permet aux utilisateurs de se familiariser plus facilement avec un plus grand nombre d'applications.

En revanche, l'expérience utilisateur de certaines applications ne vient pas nécessairement des thèmes standard. Par exemple, Lecteur Windows Media Microsoft fonctionne avec des données audio et vidéo et bénéficie d'un style d'expérience utilisateur différent. Ces interfaces utilisateur ont tendance à fournir des thèmes personnalisés, spécifiques à une application. Ces derniers sont appelés apparences et les applications dotées d'une apparence fournissent souvent des raccordements avec lesquels les utilisateurs peuvent personnaliser de nombreux aspects de l'apparence. Lecteur Windows Media Microsoft dispose de plusieurs apparences préfabriquées ainsi que d'un hôte d'apparences tierces.

Dans WPF, les thèmes et les apparences sont plus facilement définis à l'aide de dictionnaires de ressources. L'exemple suivant montre des exemples de définitions d'apparence.

<!-- Blue Skin -->
<ResourceDictionary
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:SDKSample">
  <Style TargetType="{x:Type Button}">
    <Setter Property="Background" Value="Blue" />
  </Style>


...


</ResourceDictionary>

<!-- Blue Skin -->
<ResourceDictionary
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:SDKSample">
  <Style TargetType="{x:Type Button}">
    <Setter Property="Background" Value="Blue" />
  </Style>


...


</ResourceDictionary>

<!-- Yellow Skin -->
<ResourceDictionary
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:SDKSample">
  <Style TargetType="{x:Type Button}">
    <Setter Property="Background" Value="Yellow" />
  </Style>


...


</ResourceDictionary>

<!-- Yellow Skin -->
<ResourceDictionary
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:SDKSample">
  <Style TargetType="{x:Type Button}">
    <Setter Property="Background" Value="Yellow" />
  </Style>


...


</ResourceDictionary>

Pour plus d'informations, consultez « Ressources et thèmes partagés » dans Application d'un style et création de modèles. Pour obtenir un exemple d'introduction, consultez Apparences d'application, exemple.

Contrôles personnalisés

Bien que WPF fournisse un hôte de prise en charge de la personnalisation, vous pourriez rencontrer des situations dans lesquelles des contrôles WPF existants ne satisfont pas les besoins de votre application ou de ses utilisateurs. Cela peut se produire lorsque :

• l'interface utilisateur dont vous avez besoin ne peut pas être créée en personnalisant l'apparence des implémentations WPF existantes.

• le comportement dont vous avez besoin n'est pas pris en charge (ou difficilement) par les implémentations WPF existantes.

Toutefois, à ce stade, vous pouvez tirer parti de l'un des trois modèles WPF pour créer un nouveau contrôle. Chaque modèle cible un scénario spécifique et requiert que votre contrôle personnalisé dérive d'une classe de base WPF spécifique. Les trois modèles sont répertoriés ici :

• Modèle de contrôle utilisateur. Un contrôle personnalisé dérive du UserControl et est composé d'un ou plusieurs autres contrôles.

• Modèle de contrôle. Un contrôle personnalisé dérive du Control et est utilisé pour générer des implémentations qui séparent leur comportement de leur apparence à l'aide de modèles, comme la majorité des contrôles WPF. Le fait qu'il dérive du Control offre une plus grande liberté pour créer une interface utilisateur personnalisée que des contrôles utilisateur, mais peut nécessiter plus d'effort.

• Modèle de l'élément d'infrastructure. Un contrôle personnalisé dérive de FrameworkElement lorsque son apparence est définie par une logique de rendu personnalisé (et non des modèles).

L'exemple suivant montre un contrôle numeric up-down personnalisé dérivé de UserControl.

<UserControl
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.NumericUpDown">

  <Grid>

    <Grid.RowDefinitions>
      <RowDefinition/>
      <RowDefinition/>
    </Grid.RowDefinitions>
    <Grid.ColumnDefinitions>
      <ColumnDefinition/>
      <ColumnDefinition/>
    </Grid.ColumnDefinitions>

    <!-- Value text box -->
    <Border BorderThickness="1" BorderBrush="Gray" Margin="2" Grid.RowSpan="2" 
      VerticalAlignment="Center" HorizontalAlignment="Stretch">
      <TextBlock Name="valueText" Width="60" TextAlignment="Right" Padding="5"/>
    </Border>

    <!-- Up/Down buttons -->
    <RepeatButton Name="upButton" Click="upButton_Click" Grid.Column="1" 
      Grid.Row="0">Up</RepeatButton>
    <RepeatButton Name="downButton" Click="downButton_Click" Grid.Column="1" 
      Grid.Row="1">Down</RepeatButton>

  </Grid>

</UserControl>

imports System 'EventArgs
imports System.Windows 'DependencyObject, DependencyPropertyChangedEventArgs, 
                       ' FrameworkPropertyMetadata, PropertyChangedCallback, 
                       ' RoutedPropertyChangedEventArgs
imports System.Windows.Controls 'UserControl

Namespace SDKSample

    ' Interaction logic for NumericUpDown.xaml
    Partial Public Class NumericUpDown
        Inherits System.Windows.Controls.UserControl

        'NumericUpDown user control implementation


...



    End Class

End Namespace

using System; // EventArgs
using System.Windows; // DependencyObject, DependencyPropertyChangedEventArgs,
                      // FrameworkPropertyMetadata, PropertyChangedCallback, 
                      // RoutedPropertyChangedEventArgs
using System.Windows.Controls; // UserControl

namespace SDKSample
{
    public partial class NumericUpDown : UserControl
    {
        // NumericUpDown user control implementation


...


    }
}

L'exemple suivant illustre le code XAML requis pour incorporer le contrôle utilisateur dans une Window.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.UserControlWindow"
    xmlns:local="clr-namespace:SDKSample" 
    Title="User Control Window">


...


<!-- Numeric Up/Down user control -->
<local:NumericUpDown />


...


</Window>

L'illustration suivante montre le contrôle NumericUpDown hébergé dans une Window.

Pour plus d'informations sur les contrôles personnalisés, consultez Vue d'ensemble de la création de contrôles. Pour obtenir des exemples d'introduction, consultez Exemples de personnalisation de contrôles.

Meilleures pratiques WPF

Comme pour toute plateforme de développement, WPF peut être utilisé de différentes manières pour obtenir le résultat souhaité. Afin de garantir que vos applications WPF fournissent l'expérience utilisateur requise et répondent aux demandes du public en général, il existe des meilleures pratiques pour l'accessibilité, la globalisation, la localisation et les performances. Pour plus d'informations, consultez :

• Meilleures pratiques d'accessibilité

• Vue d'ensemble de la globalisation et de la localisation WPF

• Optimisation des performances des applications WPF

• Sécurité de Windows Presentation Foundation

Résumé

WPF est une technologie de présentation complète pour générer une large gamme d'applications clientes visuellement surprenantes. Cette introduction a passé en revue les fonctionnalités clés de WPF.

L'étape suivante consiste à générer des applications WPF !

Pendant la génération de ces applications, vous pourrez revenir à cette introduction pour un petit rappel des fonctionnalités clés et pour rechercher des détails sur certaines fonctionnalités traitées dans cette introduction.

Vues d'ensemble et exemples recommandés

Les vues d'ensemble et exemples suivants sont mentionnés dans cette introduction.

Vues d'ensemble

Vue d'ensemble des graphiques 3D Meilleures pratiques d'accessibilité Vue d'ensemble de l'animation Vue d'ensemble des annotations Vue d'ensemble de la gestion d'applications Vue d'ensemble des commandes Vue d'ensemble de la création de contrôles Vue d'ensemble des contrôles Vue d'ensemble de la liaison de données Vue d'ensemble des modèles de données Vue d'ensemble des propriétés de dépendance Documents dans Windows Presentation Foundation Arborescences dans WPF Vue d'ensemble des documents dynamiques Vue d'ensemble de Geometry Débuter avec l'encre

Vue d'ensemble de l'acquisition d'images Vue d'ensemble des entrées Système de disposition Vue d'ensemble de la navigation Vue d'ensemble de l'impression Vue d'ensemble des ressources Vue d'ensemble des événements routés Vue d'ensemble des formes et dessins de base dans WPF Typographie dans Windows Presentation Foundation Sécurité de Windows Presentation Foundation Vue d'ensemble des fenêtres WPF Vue d'ensemble des pinceaux WPF Modèle de contenu WPF Vue d'ensemble de la globalisation et de la localisation WPF Vue d'ensemble des graphiques, animations et du multimédia WPF

Exemples

Solides 3D, exemple Exemples liés à l'accessibilité Galerie d'exemples d'animation Ressources d'applications, exemple Pinceaux, exemple Exemples de personnalisation de contrôles Exemples de la bibliothèque de contrôles Création d'un document XPS, exemple Liaison de données, démonstration Entrée manuscrite, exemples Sérialisation de documents, exemple Propriétés FlowDocument, exemple Géométries, exemple

Introduction aux modèles de données, exemple Introduction aux styles et aux modèles, exemple Galerie multimédia Exemples d'empaquetage Impression d'un document XPS Éléments de forme, exemple Vue d'ensemble des formes et dessins de base dans WPF Apparences d'application, exemple Style avec ControlTemplates, exemple Exemples de typographies Galerie de dispositions WPF, exemple WPF Photo Viewer, démonstration

Voir aussi

Concepts

Mise en route de Windows Presentation Foundation

Commentaires de la communauté Windows Presentation Foundation