Vue d'ensemble des fenêtres WPF

Les utilisateurs interagissent avec les applications autonomes Windows Presentation Foundation (WPF) par le biais de fenêtres. L'objectif principal d'une fenêtre est d'héberger le contenu hôte qui affiche des données et permet aux utilisateurs d'interagir avec les données. Les applications WPF autonomes fournissent leurs propres fenêtres à l'aide de la classe Window. Cette rubrique introduit Window avant de couvrir les notions de base de création et de gestion de fenêtres dans des applications autonomes.

Remarque
Les applications WPF hébergées par navigateur, y compris les XAML browser applications (XBAPs) et les pages libres Extensible Application Markup Language (XAML), ne fournissent pas leurs propres fenêtres.À la place, elles sont hébergées dans des fenêtres fournies par Windows Internet Explorer.Consultez Vue d'ensemble des applications de navigateur XAML.

Cette rubrique comprend les sections suivantes.

• La classe Window
• Implémentation d'une fenêtre
• Configuration d'une définition de fenêtre pour MSBuild
• Durée de vie d'une fenêtre
• Emplacement de la fenêtre
• Taille de la fenêtre
• Ordre de priorité des propriétés de dimensionnement
• État de la fenêtre
• Apparence de la fenêtre
• Considérations sur la sécurité
• Autres types de fenêtres
• Rubriques connexes

La classe Window

L'illustration suivante montre les parties constituantes d'une fenêtre.

Une fenêtre est divisée en deux zones : la zone non cliente et la zone cliente.

La zone non cliente d'une fenêtre est implémentée par WPF et inclut les parties d'une fenêtre qui sont communes à la plupart des fenêtres, y compris les éléments suivants :

• Une bordure.

• Une barre de titre.

• Une icône.

• Les boutons Réduire, Agrandir et Restaurer.

• Un bouton Fermer.

• Menu système avec des éléments de menu qui permettent aux utilisateurs de réduire, agrandir, restaurer, déplacer, redimensionner et fermer une fenêtre.

La zone cliente d'une fenêtre est la zone dans la zone non cliente d'une fenêtre, utilisée par les développeurs pour ajouter des contenus spécifiques à une application, tels que barres de menus, barres d'outils et contrôles.

Dans WPF, une fenêtre est encapsulée par la classe Window que vous utilisez pour effectuer les opérations suivantes :

• Afficher une fenêtre.

• Configurer la taille, la position et l'apparence d'une fenêtre.

• Héberger un contenu spécifique à une application.

• Gérer la durée de vie d'une fenêtre.

Implémentation d'une fenêtre

L'implémentation d'une fenêtre typique comprend à la fois son apparence et son comportement, où l'apparence définit à quoi ressemble une fenêtre pour les utilisateurs et le comportement définit le mode de fonctionnement d'une fenêtre lorsque les utilisateurs interagissent avec elle. Dans WPF, vous pouvez implémenter l'apparence et le comportement d'une fenêtre à l'aide du code ou du balisage XAML.

En général, toutefois, l'apparence d'une fenêtre est implémentée à l'aide du balisage XAML et son comportement est implémenté à l'aide de code-behind, comme représenté dans l'exemple suivant.

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

  <!-- Client area (for content) -->

</Window>

Imports System.Windows ' Window

Namespace SDKSample
    Partial Public Class MarkupAndCodeBehindWindow
        Inherits Window
        Public Sub New()
            InitializeComponent()
        End Sub
    End Class
End Namespace

using System.Windows; // Window

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

Pour permettre à un fichier de balisage XAML et à un fichier code-behind de fonctionner ensemble, les éléments suivants sont requis :

• Dans les balises, l'élément Window doit inclure l'attribut x:Class. Lorsque l'application est générée, l'existence de x:Class dans le fichier de balisage amène Microsoft build engine (MSBuild) à créer une classe partial qui dérive de Window et qui porte le nom spécifié par l'attribut x:Class. Cela requiert l'ajout d'une déclaration d'espace de noms XML pour le schéma XAML (xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"). La classe partial générée implémente la méthode InitializeComponent, appelée pour enregistrer les événements et définir les propriétés implémentées dans la balise.

• Dans code-behind, la classe doit être une classe partial avec le même nom spécifié par l'attribut x:Class dans la balise et elle doit dériver de Window. Cela permet au fichier code-behind d'être associé à la classe partial générée pour le fichier de balisage lorsque l'application est générée (consultez Génération d'une application WPF (WPF)).

• Dans le code-behind, la classe Window doit implémenter un constructeur qui appelle la méthode InitializeComponent. InitializeComponent est implémenté par la classe partial générée du fichier de balisage pour enregistrer les événements et configurer les propriétés définies dans le balisage.

Remarque
Lorsque vous ajoutez un nouveau Window à votre projet en utilisant Microsoft Visual Studio, Window est implémenté à l'aide du balisage et du code-behind et il inclut la configuration nécessaire pour créer l'association entre les fichiers de balisage et les fichiers code-behind comme décrit ici.

Une fois cette configuration en place, vous pouvez vous concentrer sur la définition de l'apparence de la fenêtre dans le balisage XAML et l'implémentation de son comportement dans code-behind. L'exemple suivant montre une fenêtre avec un bouton, implémentée dans le balisage XAML et un gestionnaire d'événements pour l'événement Click du bouton, implémenté dans code-behind.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MarkupAndCodeBehindWindow">
  <!-- Client area (for content) -->
  <Button Click="button_Click">Click This Button</Button>
</Window>

Imports System.Windows

Namespace SDKSample
    Partial Public Class MarkupAndCodeBehindWindow
        Inherits Window
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub button_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            MessageBox.Show("Button was clicked.")
        End Sub
    End Class
End Namespace

using System.Windows;

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

        void button_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Button was clicked.");
        }
    }
}

Configuration d'une définition de fenêtre pour MSBuild

La manière dont vous implémentez votre fenêtre détermine comment elle est configurée pour MSBuild. Pour une fenêtre définie à l'aide du balisage XAML et du code-behind :

• Les fichiers de balisage XAML sont configurés comme éléments Page MSBuild.

• Les fichiers code-behind sont configurés comme éléments Compile MSBuild.

Cela est indiqué dans le fichier projet MSBuild suivant.

<Project ... xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
    ...
    <Page Include="MarkupAndCodeBehindWindow.xaml" />
    <Compile Include=" MarkupAndCodeBehindWindow.xaml.cs" />
    ...
</Project>

Pour plus d'informations sur la génération d'applications WPF, consultez Génération d'une application WPF (WPF).

Durée de vie d'une fenêtre

Comme avec toute classe, une fenêtre a une durée de vie qui commence lors de sa première instanciation, après quoi elle est ouverte, activée et désactivée et finalement fermée.

Cette section comprend les sous-sections suivantes.

• Ouverture d'une fenêtre
• Activation de fenêtre
• Fermeture d'une fenêtre
• Événements de la durée de vie de la fenêtre

Ouverture d'une fenêtre

Pour ouvrir une fenêtre, vous commencez par en créer une instance, comme montré dans l'exemple suivant.

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

Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub app_Startup(ByVal sender As Object, ByVal e As StartupEventArgs)
            ' Create a window
            Dim window As New MarkupAndCodeBehindWindow()

            ' Open a window
            window.Show()
        End Sub
    End Class
End Namespace

using System.Windows;
namespace SDKSample
{
    public partial class App : Application
    {
        void app_Startup(object sender, StartupEventArgs e)
        {
            // Create a window
            MarkupAndCodeBehindWindow window = new MarkupAndCodeBehindWindow();

            // Open a window
            window.Show();
        }
    }
}

Dans cet exemple, le MarkupAndCodeBehindWindow est instancié lorsque l'application démarre, ce qui se produit lorsque l'événement Startup est déclenché.

Lorsqu'une fenêtre est instanciée, une référence à celle-ci est ajoutée automatiquement à une liste de fenêtres gérée par l'objet Application (consultez Application.Windows). En outre, la première fenêtre à être instanciée est, par défaut, définie par Application comme fenêtre d'application principale (consultez Application.MainWindow).

Pour finir, la fenêtre est ouverte en appelant la méthode Show ; le résultat est indiqué dans l'illustration suivante.

Une fenêtre ouverte en appelant Show est une fenêtre non modale, ce qui signifie que l'application fonctionne selon un mode permettant aux utilisateurs d'activer d'autres fenêtres dans la même application.

Remarque
ShowDialog est appelé pour ouvrir en mode modal des fenêtres telles que des boîtes de dialogue.Pour plus d'informations, consultez Vue d'ensemble des boîtes de dialogue.

Lorsque Show est appelé, une fenêtre exécute un travail d'initialisation avant qu'elle ne soit affichée afin d'établir une infrastructure lui permettant de recevoir des entrées d'utilisateur. Lorsque la fenêtre est initialisée, l'événement SourceInitialized est déclenché et la fenêtre est affichée.

Comme raccourci, StartupUri peut être configuré pour spécifier la première fenêtre ouverte automatiquement lorsqu'une application démarre.

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

Lorsque l'application démarre, la fenêtre spécifiée par la valeur de StartupUri est ouverte de façon non modale ; en interne, la fenêtre est ouverte en appelant sa méthode Show.

Propriété de fenêtre

Une fenêtre ouverte à l'aide de la méthode Show ne possède pas de relation implicite avec la fenêtre qui l'a créée ; les utilisateurs peuvent interagir indépendamment avec l'une ou l'autre fenêtre, ce qui signifie que l'une ou l'autre fenêtre peut effectuer les opérations suivantes :

• Recouvrir l'autre fenêtre (à moins que la propriété Topmost d'une des fenêtres ait la valeur true).

• Être réduite, agrandie et restaurée sans affecter l'autre fenêtre.

Certaines fenêtres requièrent une relation avec la fenêtre qui les ouvre. Par exemple, une application d'Integrated Development Environment (IDE) peut ouvrir des fenêtres de propriété et des fenêtres Outil dont le comportement typique est de couvrir la fenêtre qui les crée. En outre, ces fenêtres doivent toujours se fermer, se réduire, s'agrandir et se restaurer de concert avec la fenêtre qui les a créées. Une telle relation peut être établie en faisant de sorte qu'une fenêtre en possède une autre ; ceci est accompli en affectant à la propriété Owner de la fenêtre possédée une référence à la fenêtre propriétaire. L'exemple suivant le démontre.

' Create a window and make this window its owner
Dim ownedWindow As New Window()
ownedWindow.Owner = Me
ownedWindow.Show()

// Create a window and make this window its owner
Window ownedWindow = new Window();
ownedWindow.Owner = this;
ownedWindow.Show();

Après établissement de la propriété :

• La fenêtre possédée peut référencer sa fenêtre propriétaire en consultant la valeur de sa propriété Owner.

• La fenêtre propriétaire peut découvrir toutes les fenêtres qu'elle possède en consultant la valeur de sa propriété OwnedWindows.

Empêcher l'activation de fenêtres

Dans certains scénarios, les fenêtres ne doivent pas être activées lorsque qu'elles sont affichées (fenêtres de conversation d'une application de style Messenger sur Internet ou fenêtres de notification d'une application de messagerie, par exemple).

Si votre application possède une fenêtre qui ne doit pas être activée lorsque qu'elle est affichée, vous pouvez affecter à sa propriété ShowActivated la valeur false avant d'appeler la méthode Show pour la première fois. En conséquence :

• La fenêtre n'est pas activée.

• L'événement Activated de la fenêtre n'est pas déclenché.

• La fenêtre actuellement activée reste activée.

La fenêtre sera toutefois activée dès que l'utilisateur l'activera en cliquant sur la zone cliente ou non cliente. Dans ce cas :

• La fenêtre est activée.

• L'événement Activated de la fenêtre est déclenché.

• La fenêtre précédemment activée est désactivée.

• Les événements Deactivated et Activated de la fenêtre sont ensuite déclenchés comme prévu, en réponse à des actions de l'utilisateur.

Activation de fenêtre

Lors de la première ouverture d'une fenêtre, elle devient la fenêtre active (sauf si elle est affichée avec ShowActivated ayant la valeur false). La fenêtre active est la fenêtre qui capture actuellement les entrées d'utilisateur, telles les séquences de touches et les clics de souris. Lorsqu'une fenêtre devient active, elle déclenche l'événement Activated.

Remarque
Lorsqu'une fenêtre est ouverte initialement, les événements Loaded et ContentRendered ne sont déclenchés qu'après après le déclenchement de l'événement Activated.Il s'ensuit qu'une fenêtre peut effectivement être considérée ouverte lorsque ContentRendered est déclenché.

Après qu'une fenêtre soit devenue active, un utilisateur peut activer une autre fenêtre dans la même application ou activer une autre application. Lorsque cela se produit, la fenêtre actuellement active est désactivée et déclenche l'événement Deactivated. De même, lorsque l'utilisateur sélectionne une fenêtre actuellement désactivée, celle-ci redevient active et Activated est déclenché.

Une raison commune de gérer Activated et Deactivated est d'activer et de désactiver une fonctionnalité qui ne peut s'exécuter que lorsqu'une fenêtre est active. Par exemple, certaines fenêtres affichent un contenu interactif qui requiert en permanence l'attention de l'utilisateur ou des entrées de sa part, notamment les jeux vidéo et les lecteurs de vidéo. L'exemple suivant est un lecteur de vidéo simplifié qui montre comment gérer Activated et Deactivated pour implémenter ce comportement.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.CustomMediaPlayerWindow"
    Activated="window_Activated"
    Deactivated="window_Deactivated">

    <!-- Media Player -->
    <MediaElement 
      Name="mediaElement" 
      Stretch="Fill" 
      LoadedBehavior="Manual" 
      Source="numbers.wmv" />

</Window>

Imports System ' EventArgs
Imports System.Windows ' Window

Namespace SDKSample
    Partial Public Class CustomMediaPlayerWindow
        Inherits Window
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub window_Activated(ByVal sender As Object, ByVal e As EventArgs)
            ' Recommence playing media if window is activated
            Me.mediaElement.Play()
        End Sub

        Private Sub window_Deactivated(ByVal sender As Object, ByVal e As EventArgs)
            ' Pause playing if media is being played and window is deactivated
            Me.mediaElement.Pause()
        End Sub
    End Class
End Namespace

using System; // EventArgs
using System.Windows; // Window

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

        void window_Activated(object sender, EventArgs e)
        {
            // Recommence playing media if window is activated
            this.mediaElement.Play();
        }

        void window_Deactivated(object sender, EventArgs e)
        {
            // Pause playing if media is being played and window is deactivated
            this.mediaElement.Pause();
        }
    }
}

D'autres types d'applications peuvent encore exécuter du code en arrière-plan lorsqu'une fenêtre est désactivée. Par exemple, un client de messagerie peut continuer à interroger le serveur de messagerie pendant que l'utilisateur utilise d'autres applications. Des applications de ce type fournissent souvent un comportement différent ou supplémentaire pendant que la fenêtre principale est désactivée. En ce qui concerne le programme de messagerie, cela peut signifier l'ajout du nouvel élément de messagerie à la boîte de réception ainsi que celui d'une icône de notification dans la barre d'état système. Une icône de notification n'a besoin d'être affichée que lorsque la fenêtre de courrier n'est pas active, ce qui peut être déterminé en examinant la propriété IsActive.

Si une tâche en arrière-plan se termine, une fenêtre peut souhaiter notifier plus rapidement l'utilisateur en appelant la méthode Activate. Si l'utilisateur interagit avec une autre application activée lorsque Activate est appelé, le bouton de la barre des tâches de la fenêtre clignote. Si un utilisateur interagit avec l'application actuelle, l'appel de Activate ramènera la fenêtre au premier plan.

Remarque
Vous pouvez gérer l'activation de la portée application à l'aide des événements Application.Activated et Application.Deactivated.

Fermeture d'une fenêtre

La durée de vie d'une fenêtre est proche de sa fin lorsqu'un utilisateur la ferme. Une fenêtre peut être fermée à l'aide d'éléments dans la zone non cliente, y compris les suivants :

• L'élément Fermer du menu Système.

• Appuyer sur la touche ALT+F4.

• Appuyer sur le bouton Fermer.

Vous pouvez fournir des mécanismes supplémentaires à la zone cliente pour fermer une fenêtre, dont les plus communs incluent les suivants :

• Un élément Quitter dans le menu Fichier, généralement pour les fenêtres d'application principales.

• Un élément Fermer dans le menu Fichier, généralement sur une fenêtre d'application secondaire.

• Un bouton Annuler, généralement sur une boîte de dialogue modale.

• Un bouton Fermer, généralement sur une boîte de dialogue non modale.

Pour fermer une fenêtre en réponse à l'un de ces mécanismes personnalisés, vous devez appeler la méthode Close. L'exemple suivant implémente la capacité de fermer une fenêtre en choisissant Quitter dans le menu Fichier.

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

  <Menu>
    <MenuItem Header="_File">
      <MenuItem Header="E_xit" Click="fileExitMenuItem_Click" />
    </MenuItem>
  </Menu>

</Window>

Imports System.Windows ' window, RoutedEventArgs

Namespace SDKSample
    Partial Public Class WindowWithFileExit
        Inherits System.Windows.Window
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub fileExitMenuItem_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            ' Close this window
            Me.Close()
        End Sub
    End Class
End Namespace

using System.Windows; // window, RoutedEventArgs

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

        void fileExitMenuItem_Click(object sender, RoutedEventArgs e)
        {
            // Close this window
            this.Close();
        }
    }
}

Lorsqu'une fenêtre se ferme, elle déclenche deux événements : Closing et Closed.

Closing est déclenché avant que la fenêtre ne se ferme et il fournit un mécanisme grâce auquel la fermeture de la fenêtre peut être empêchée. Une raison commune d'empêcher la fermeture d'une fenêtre est lorsque son contenu a été modifié. Dans cette situation, l'événement Closing peut être géré pour déterminer si les données sont modifiées et, dans ce cas, demander à l'utilisateur s'il faut continuer à fermer la fenêtre sans enregistrer les données ou annuler la fermeture. L'exemple suivant montre les aspects clés de la gestion de Closing.

Imports System ' EventArgs
Imports System.ComponentModel ' CancelEventArgs
Imports System.Windows ' window

Namespace VisualBasic
    Partial Public Class DataWindow
        Inherits Window
        ' Is data dirty
        Private isDataDirty As Boolean = False


...


        Private Sub DataWindow_Closing(ByVal sender As Object, ByVal e As CancelEventArgs)
            MessageBox.Show("Closing called")

            ' If data is dirty, notify user and ask for a response
            If Me.isDataDirty Then
                Dim msg As String = "Data is dirty. Close without saving?"
                Dim result As MessageBoxResult = MessageBox.Show(msg, "Data App", MessageBoxButton.YesNo, MessageBoxImage.Warning)
                If result = MessageBoxResult.No Then
                    ' If user doesn't want to close, cancel closure
                    e.Cancel = True
                End If
            End If
        End Sub
    End Class
End Namespace

using System; // EventArgs
using System.ComponentModel; // CancelEventArgs
using System.Windows; // window

namespace CSharp
{
    public partial class DataWindow : Window
    {
        // Is data dirty
        bool isDataDirty = false;


...


        void DataWindow_Closing(object sender, CancelEventArgs e)
        {
            MessageBox.Show("Closing called");

            // If data is dirty, notify user and ask for a response
            if (this.isDataDirty)
            {
                string msg = "Data is dirty. Close without saving?";
                MessageBoxResult result = 
                  MessageBox.Show(
                    msg, 
                    "Data App", 
                    MessageBoxButton.YesNo, 
                    MessageBoxImage.Warning);
                if (result == MessageBoxResult.No)
                {
                    // If user doesn't want to close, cancel closure
                    e.Cancel = true;
                }
            }
        }
    }
}

Le gestionnaire d'événements CancelEventArgs reçoit un Closing qui implémente la propriété BooleanCancel à laquelle vous affectez la valeur true pour empêcher une fenêtre de se fermer.

Si Closing n'est pas géré, ou géré mais non annulé, la fenêtre se fermera. Juste avant qu'une fenêtre ne se ferme réellement, Closed est déclenché. À ce stade, on ne peut pas empêcher une fenêtre de se fermer.

Remarque
Une application peut être configurée pour se fermer automatiquement lors de la fermeture de la fenêtre d'application principale (consultez MainWindow) ou lors de la fermeture de la dernière fenêtre.Pour plus d'informations, consultez ShutdownMode.

Bien qu'une fenêtre puisse être fermée explicitement par le biais de mécanismes fournis dans les zones clientes et non-clientes, une fenêtre peut également être fermée implicitement par suite du comportement dans d'autres parties de l'application ou de Windows, y compris les éléments suivants :

• Un utilisateur se déconnecte ou arrête Windows.

• Le propriétaire d'une fenêtre se ferme (consultez Owner).

• La fenêtre d'application principale est fermée et ShutdownMode est OnMainWindowClose.

• Shutdown est appelé.

Remarque
Une fenêtre ne peut pas être rouverte après sa fermeture.

Événements de la durée de vie de la fenêtre

L'illustration suivante montre la séquence des événements principaux de la durée de vie d'une fenêtre.

L'illustration suivante montre la séquence des principaux événements de la durée de vie d'une fenêtre affichée sans activation (ShowActivated a la valeur false avant l'affichage de la fenêtre).

Emplacement de la fenêtre

Lorsqu'une fenêtre est ouverte, elle dispose d'un emplacement dans les dimensions x et y du Bureau. Cet emplacement peut être déterminé en consultant les propriétés Left et Top, respectivement. Vous pouvez définir ces propriétés pour modifier l'emplacement de la fenêtre.

Vous pouvez également spécifier l'emplacement initial d'un Window lorsqu'il apparaît pour la première fois en définissant la propriété WindowStartupLocation avec l'une des valeurs d'énumération WindowStartupLocation suivantes :

• Manual (par défaut)

• CenterScreen

• CenterOwner

Si l'emplacement de démarrage est spécifié comme Manual et que les propriétés Left et Top n'ont pas été définies, Window demandera Windows un emplacement dans lequel apparaître.

Fenêtres au premier plan et ordre de plan

Outre un emplacement dans les dimensions X et Y, une fenêtre possède également un emplacement dans la dimension Z, qui détermine sa position verticale par rapport à d'autres fenêtres. Ceci est connu comme l'ordre de plan de la fenêtre, et il existe deux types : l'ordre de plan normal et l'ordre de plan le plus haut. L'emplacement d'une fenêtre dans l' ordre de plan normal est déterminé par le fait qu'elle est actuellement active ou non. Par défaut, une fenêtre est située dans l'ordre de plan normal. L'emplacement d'une fenêtre dans l' ordre de plan le plus haut est également déterminé par le fait qu'elle est active ou non. En outre, les fenêtres dans l'ordre de plan le plus haut sont toujours situées au-dessus des fenêtres précitées dans l'ordre de plan normal. Une fenêtre est située dans l'ordre de plan le plus haut en affectant à sa propriété Topmost la valeur true.

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


...


</Window>

Dans chaque ordre de plan, la fenêtre active apparaît au-dessus de toutes les autres fenêtres dans le même ordre de plan.

Taille de la fenêtre

Outre le fait d'avoir un emplacement sur le bureau, une fenêtre a une taille déterminée par plusieurs propriétés, notamment diverses propriétés de largeur et de hauteur et SizeToContent.

MinWidth, Width et MaxWidth sont utilisés pour gérer la plage des largeurs qu'une fenêtre peut avoir pendant sa durée de vie et sont configurés comme indiqué dans l'exemple suivant.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    MinWidth="300" Width="400" MaxWidth="500">


...


</Window>

La hauteur de fenêtre est gérée par MinHeight, Height et MaxHeight et est configurée comme indiqué dans l'exemple suivant.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    MinHeight="300" Height="400" MaxHeight="500">


...


</Window>

Comme les diverses valeurs de largeur et de hauteur spécifient chacune une plage, il est possible pour la largeur et la hauteur d'une fenêtre redimensionnable de se situer n'importe où dans la plage spécifiée pour la dimension respective. Pour détecter sa largeur et sa hauteur actuelle, consultez ActualWidth et ActualHeight, respectivement.

Si vous souhaitez que la largeur et la hauteur de votre fenêtre correspondent à la taille du contenu de la fenêtre, vous pouvez utiliser la propriété SizeToContent, qui possède les valeurs suivantes :

• Manual. Aucun effet (valeur par défaut).

• Width. Ajuster à la largeur du contenu, qui a le même effet qu'affecter MinWidth et MaxWidth à la largeur du contenu.

• Height. Ajuster à la hauteur du contenu, qui a le même effet qu'affecter MinHeight et MaxHeight à la hauteur du contenu.

• WidthAndHeight. Ajuster à la largeur et à la hauteur du contenu, qui a le même effet qu'affecter MinHeight et MaxHeight à la hauteur du contenu et qu'affecter MinWidth et MaxWidth à la largeur du contenu.

Le code suivant montre une fenêtre qui s'ajuste automatiquement en fonction de son contenu, verticalement et horizontalement, lors de son affichage initial.

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


...


</Window>

Ordre de priorité des propriétés de dimensionnement

Pour l'essentiel, les diverses propriétés de dimensionnement d'une fenêtre se combinent pour définir la plage de largeur et de hauteur pour une fenêtre redimensionnable. Afin d'assurer une plage valide, Window évalue les valeurs des propriétés de taille en fonction des ordres de priorité suivants.

Pour les propriétés de hauteur :

1. FrameworkElement.MinHeight >

2. FrameworkElement.MaxHeight >

3. SizeToContent.Height/SizeToContent.WidthAndHeight >

4. FrameworkElement.Height

Pour les propriétés de largeur :

1. FrameworkElement.MinWidth >

2. FrameworkElement.MaxWidth >

3. SizeToContent.Width/SizeToContent.WidthAndHeight >

4. FrameworkElement.Width

L'ordre de priorité peut également déterminer la taille d'une fenêtre lorsqu'elle est agrandie, à l'aide de la propriété WindowState.

État de la fenêtre

Pendant la durée de vie d'une fenêtre redimensionnable, celle-ci peut posséder trois états : normal, réduit et agrandi. L'état par défaut d'une fenêtre est l'état normal. Une fenêtre possédant cet état permet à un utilisateur de la déplacer et de la redimensionner à l'aide d'une poignée de dimensionnement ou de la bordure, pour autant qu'elle soit redimensionnable.

Une fenêtre dont l'état est réduit est réduite à son bouton de la barre des tâches si ShowInTaskbar a la valeur true ; sinon, elle est réduite à la plus petite taille possible qu'elle peut avoir et se place dans le coin inférieur gauche du bureau. Aucun type de fenêtre réduite ne peut être redimensionné à l'aide d'une bordure ou d'une poignée de dimensionnement, bien qu'une fenêtre réduite qui n'est pas affichée dans la barre des tâches puisse être déplacée en tout point du bureau.

Une fenêtre dont l'état est agrandi se développe à la taille maximale possible, laquelle ne peut être supérieure à ce qui est déterminé par ses propriétés MaxWidth, MaxHeight et SizeToContent. Comme une fenêtre réduite, une fenêtre agrandie ne peut pas être redimensionnée à l'aide d'une poignée de dimensionnement ou en faisant glisser sa bordure.

Remarque
Les valeurs des propriétés Top, Left, Widthet Height d'une fenêtre représentent toujours les valeurs pour l'état normal, même quand la fenêtre est actuellement agrandie ou réduite.

L'état d'une fenêtre peut être configuré en définissant sa propriété WindowState qui peut avoir l'une des valeurs d'énumération WindowState suivantes :

• Normal (par défaut)

• Maximized

• Minimized

L'exemple suivant montre comment créer une fenêtre qui sera agrandie lors de son ouverture.

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


...


</Window>

En général, vous devez définir WindowState pour configurer l'état initial d'une fenêtre. Une fois qu'une fenêtre redimensionnable est affichée, les utilisateurs peuvent cliquer sur les boutons de réduction, d'agrandissement et de restauration dans la barre de titre de la fenêtre pour modifier son état.

Apparence de la fenêtre

Vous modifiez l'apparence de la zone cliente d'une fenêtre en lui ajoutant un contenu qui lui est spécifique, tel que des boutons, des étiquettes et des zones de texte. Pour configurer la zone non cliente, Window fournit plusieurs propriétés, qui incluent Icon pour définir l'icône d'une fenêtre et Title pour définir son titre.

Vous pouvez également modifier l'apparence et le comportement d'une bordure de zone non cliente en configurant le mode de redimensionnement d'une fenêtre, le style de fenêtre, et si celle-ci apparaît sous forme d'un bouton dans la barre des tâches du bureau.

Cette section comprend les sous-sections suivantes.

• Mode redimensionnement
• Style de fenêtre
• Présence de la barre des tâches

Mode redimensionnement

Selon la propriété WindowStyle, vous pouvez contrôler comment (et si) les utilisateurs peuvent redimensionner la fenêtre. Le choix de style de fenêtre détermine si un utilisateur peut redimensionner la fenêtre en faisant glisser sa bordure avec la souris, si les boutons Réduire, Agrandir et Redimensionner apparaissent sur la zone non cliente et, dans ce cas, s'ils sont activés.

Vous pouvez configurer la manière dont une fenêtre se redimensionne en définissant sa propriété ResizeMode qui peut avoir l'une des valeurs d'énumération ResizeMode suivantes :

• NoResize

• CanMinimize

• CanResize (par défaut)

• CanResizeWithGrip

Comme avec WindowStyle, il est improbable que le mode de redimensionnement d'une fenêtre change pendant sa durée de vie, ce qui signifie que vous le définirez très probablement à partir du balisage XAML.

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


...


</Window>

Notez que vous pouvez détecter si une fenêtre est agrandie, réduite ou restaurée en consultant la propriété WindowState.

Style de fenêtre

La bordure exposée à partir de la zone non cliente d'une fenêtre est appropriée pour la plupart des applications. Toutefois, il arrive que dans certaines circonstances des types de bordures différents soient requis, voire qu'aucune bordure ne soit requise, selon le type de fenêtre.

Pour contrôler quel type de bordure une fenêtre récupère, vous définissez sa propriété WindowStyle avec l'une des valeurs suivantes de l'énumération WindowStyle :

• None

• SingleBorderWindow (par défaut)

• ThreeDBorderWindow

• ToolWindow

L'effet de ces styles de fenêtre est représenté dans l'illustration suivante.

Vous pouvez définir WindowStyle à l'aide du balisage XAML ou du code ; comme il est improbable que cela change pendant la durée de vie d'une fenêtre, vous le configurerez très probablement à l'aide du balisage XAML.

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


...


</Window>

Style de fenêtre non rectangulaire

Il existe également des situations où les styles de bordure que WindowStyle vous permet d'obtenir ne suffisent pas. Par exemple, vous pouvez souhaiter créer une application avec une bordure non rectangulaire, semblable à celle du Microsoft Windows Media Player.

Considérons, par exemple, la fenêtre de la bulle de commentaire représentée dans l'illustration suivante.

Ce type de fenêtre peut être créé en affectant à la propriété WindowStyle la valeur None, et en utilisant un support spécial que Window a pour transparence.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowStyle="None"
    AllowsTransparency="True"
    Background="Transparent">


...


</Window>

Cette combinaison de valeurs indique à la fenêtre de restituer un rendu totalement transparent. Dans cet état, les ornements de la zone non cliente (le menu Fermer, les boutons Réduire, Agrandir et Restaurer, etc.) de la fenêtre ne peuvent pas être utilisés. Par conséquent, vous devez fournir vos propres ornements.

Présence de la barre des tâches

L'apparence par défaut d'une fenêtre inclut un bouton de barre des tâches, comme celui représenté dans l'illustration suivante.

Certains types de fenêtres ne possèdent pas de bouton de barre des tâches, telles que les boîtes de messages et de dialogue (consultez Vue d'ensemble des boîtes de dialogue). Vous pouvez contrôler si le bouton de barre des tâches pour une fenêtre est affiché en définissant la propriété ShowInTaskbar (true par défaut).

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


...


</Window>

Considérations sur la sécurité

Window requiert l'autorisation de sécurité UnmanagedCode pour être instancié. Pour les applications installées sur l'ordinateur local et lancées à partir de celui-ci, cela fait partie du jeu des autorisations accordées à l'application.

Cela ne fait toutefois pas partie du jeu d'autorisations accordé aux applications lancées à partir de la zone Internet ou de la zone d'intranet local à l'aide de ClickOnce. Par conséquent, les utilisateurs recevront un avertissement de sécurité ClickOnce et devront élever le jeu d'autorisations pour l'application à Confiance totale.

En outre, les applications XBAPs ne peuvent pas afficher par défaut de fenêtres ni de boîtes de dialogue. Pour une discussion sur les considérations relatives à la sécurité des applications autonomes, consultez Stratégie de sécurité de WPF - ingénierie de la plateforme.

Autres types de fenêtres

NavigationWindow est une fenêtre conçue pour héberger un contenu navigable. Pour plus d'informations, consultez Vue d'ensemble de la navigation.

Les boîtes de dialogue sont des fenêtres qui sont souvent utilisées pour rassembler des informations d'un utilisateur pour compléter une fonction. Par exemple, lorsqu'un utilisateur souhaite ouvrir un fichier, la boîte de dialogue Ouvrir un fichier est généralement affichée par une application pour obtenir le nom de fichier auprès de l'utilisateur. Pour plus d'informations, consultez Vue d'ensemble des boîtes de dialogue.

Voir aussi

Référence

Window

MessageBox

NavigationWindow

Application

Concepts

Vue d'ensemble des boîtes de dialogue

Génération d'une application WPF (WPF)