Vue d’ensemble des fenêtres WPF (WPF .NET)

Les utilisateurs interagissent avec des applications Windows Presentation Foundation (WPF) via windows. L’objectif principal d’une fenêtre est d’héberger du contenu qui permet aux utilisateurs de visualiser les données et d’interagir avec celles-ci. Les applications WPF fournissent leurs propres fenêtres à l’aide de la Window classe. Cet article présente Window avant de couvrir les principes fondamentaux de la création et de la gestion de fenêtres dans les applications.

Important

Cet article utilise le code XAML généré à partir d’un projet C# . Si vous utilisez Visual Basic, le code XAML peut sembler légèrement différent. Ces différences sont généralement présentes sur x:Class les valeurs d’attribut. C# inclut l’espace de noms racine du projet alors que Visual Basic ne le fait pas.

Les modèles de projet pour C# créent un App type contenu dans le fichier app.xaml . Dans Visual Basic, le type est nommé Application et le fichier est nommé Application.xaml.

Classe Window

Dans WPF, une fenêtre est encapsulée par la Window classe 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 à l’application ;
  • gérer la durée de vie d’une fenêtre.

La figure suivante illustre les parties constituantes d’une fenêtre :

Screenshot that shows parts of a WPF window.

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 communes à la plupart des fenêtres, notamment les suivantes :

  • Barre de titre (1-5).
  • Icône (1).
  • Titre (2).
  • Réduire (3), Agrandir (4) et Fermer (5) boutons.
  • Menu système (6) avec des éléments de menu. Apparaît lorsque vous cliquez sur l’icône (1).
  • Bordure (7).

La zone cliente d’une fenêtre est la zone dans la zone non cliente d’une fenêtre et est utilisée par les développeurs pour ajouter du contenu spécifique à l’application, comme les barres de menus, les barres d’outils et les contrôles.

  • Zone cliente (8).
  • Redimensionner la poignée (9). Il s’agit d’un contrôle ajouté à la zone Client (8).

Implémentation d’une fenêtre

L’implémentation d’une fenêtre classique inclut à la fois l’apparence et le comportement, où l’apparence définit l’apparence d’une fenêtre aux utilisateurs et le comportement définit la façon dont une fenêtre fonctionne à mesure que les utilisateurs interagissent avec elle. Dans WPF, vous pouvez implémenter l’apparence et le comportement d’une fenêtre à l’aide de code ou de 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 du code-behind, comme illustré dans l’exemple suivant.

<Window x:Class="WindowsOverview.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WindowsOverview"
        >

    <!-- Client area containing the content of the window -->
    
</Window>

Le code suivant est le code-behind pour le code XAML.

using System.Windows;

namespace WindowsOverview
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }
    }
}
Public Class Window1

End Class

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

  • Dans le balisage, l’élément Window doit inclure l’attribut x:Class . Lorsque l’application est générée, l’existence d’un x:Class attribut entraîne le moteur de build Microsoft (MSBuild) à générer une partial classe qui dérive du Window nom spécifié par l’attributx:Class. Cela nécessite l’ajout d’une déclaration d’espace de noms XML pour le schéma XAML (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"). La classe générée partial implémente la InitializeComponent méthode, qui est appelée pour inscrire les événements et définir les propriétés implémentées dans le balisage.

  • Dans code-behind, la classe doit être une partial classe portant le même nom que celui spécifié par l’attribut dans le x:Class balisage et doit dériver de Window. Cela permet au fichier code-behind d’être associé à la partial classe générée pour le fichier de balisage lorsque l’application est générée, pour plus d’informations, consultez Compiler une application WPF.

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

Notes

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

Avec 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 le code-behind. L’exemple suivant montre une fenêtre avec un bouton qui définit un gestionnaire d’événements pour l’événement Click . Cela est implémenté dans le code XAML et le gestionnaire est implémenté dans le code-behind.

<Window x:Class="WindowsOverview.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WindowsOverview"
        >

    <!-- Client area containing the content of the window -->

    <Button Click="Button_Click">Click This Button</Button>
    
</Window>

Le code suivant est le code-behind pour le code XAML.

using System.Windows;

namespace WindowsOverview
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Button was clicked.");
        }
    }
}
Public Class Window1

    Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
        MessageBox.Show("Button was clicked.")
    End Sub

End Class

Configuration d’une fenêtre pour MSBuild

La façon 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 en tant qu’éléments MSBuildPage.
  • Les fichiers code-behind sont configurés en tant qu’éléments MSBuildCompile.

Les projets du Kit de développement logiciel (SDK) .NET importent automatiquement les éléments appropriés Page et Compile vous n’avez pas besoin de les déclarer. Lorsque le projet est configuré pour WPF, les fichiers de balisage XAML sont automatiquement importés en tant qu’éléments Page , et le fichier code-behind correspondant est importé en tant que Compile.

MSBuild projets n’importeront pas automatiquement les types et vous devez les déclarer vous-même :

<Project>
    ...
    <Page Include="MarkupAndCodeBehindWindow.xaml" />
    <Compile Include=" MarkupAndCodeBehindWindow.xaml.cs" />
    ...
</Project>

Pour plus d’informations sur la création d’applications WPF, consultez Compiler une application WPF.

Durée de vie des fenêtres

Comme pour n’importe quelle classe, une fenêtre a une durée de vie qui commence lorsqu’elle est instanciée pour la première fois, après laquelle elle est ouverte, activée/désactivée, puis fermée.

Ouverture d’une fenêtre

Pour ouvrir une fenêtre, vous créez d’abord une instance de celle-ci, illustrée dans l’exemple suivant :

using System.Windows;

namespace WindowsOverview
{
    public partial class App : Application
    {
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            // Create the window
            Window1 window = new Window1();

            // Open the window
            window.Show();
        }
    }
}
Class Application

    Private Sub Application_Startup(sender As Object, e As StartupEventArgs)
        ' Create the window
        Dim window As New Window1

        ' Open the window
        window.Show()
    End Sub

End Class

Dans cet exemple Window1 , il est instancié au démarrage de l’application, ce qui se produit lorsque l’événement Startup est déclenché. Pour plus d’informations sur la fenêtre de démarrage, consultez Comment obtenir ou définir la fenêtre principale de l’application.

Lorsqu’une fenêtre est instanciée, une référence à celle-ci est automatiquement ajoutée à une liste de fenêtres gérées par l’objet Application . La première fenêtre à instancier est automatiquement définie comme Applicationfenêtre principale de l’application.

La fenêtre est enfin ouverte en appelant la Show méthode comme indiqué dans l’image suivante :

WPF Window with a single button inside.

Une fenêtre ouverte en appelant Show est une fenêtre sans mode et l’application n’empêche pas les utilisateurs d’interagir avec d’autres fenêtres de l’application. L’ouverture d’une fenêtre avec ShowDialog ouvre une fenêtre en tant que modale et limite l’interaction de l’utilisateur à la fenêtre spécifique. Pour plus d’informations, consultez Vue d’ensemble des boîtes de dialogue.

Lorsqu’elle Show est appelée, une fenêtre effectue un travail d’initialisation avant de s’afficher pour établir l’infrastructure qui lui permet de recevoir des entrées utilisateur. Lorsque la fenêtre est initialisée, l’événement SourceInitialized est déclenché et la fenêtre s’affiche.

Pour plus d’informations, voir Comment ouvrir une fenêtre ou une boîte de dialogue.

Fenêtre de démarrage

L’exemple précédent a utilisé l’événement pour exécuter du Startup code qui affichait la fenêtre d’application initiale. En guise de raccourci, utilisez StartupUri plutôt pour spécifier le chemin d’accès à un fichier XAML dans votre application. L’application crée et affiche automatiquement la fenêtre spécifiée par cette propriété.

<Application x:Class="WindowsOverview.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:local="clr-namespace:WindowsOverview"
             StartupUri="ClippedWindow.xaml">
    <Application.Resources>
         
    </Application.Resources>
</Application>

Propriété de la fenêtre

Une fenêtre ouverte à l’aide de la Show méthode n’a pas de relation implicite avec la fenêtre qui l’a créée. Les utilisateurs peuvent interagir avec l’une ou l’autre fenêtre indépendamment de l’autre, ce qui signifie que l’une ou l’autre des fenêtres peut effectuer les opérations suivantes :

  • Couvrez l’autre (sauf si l’une des fenêtres a sa Topmost propriété définie truesur ).
  • être réduite, agrandie et restaurée sans affecter l’autre fenêtre.

Certaines fenêtres nécessitent une relation avec la fenêtre qui les ouvre. Par exemple, une application IDE (Integrated Development Environment) peut ouvrir des fenêtres de propriétés et des fenêtres outil dont le comportement classique consiste à couvrir la fenêtre qui les crée. De plus, ces fenêtres doivent toujours se fermer, se réduire, s’agrandir et se restaurer conjointement avec la fenêtre qui les a créées. Une telle relation peut être établie en rendant une autre fenêtre propriétaire , et est obtenue en définissant la Owner propriété de la fenêtre détenue avec une référence à la fenêtre propriétaire. Cela est illustré par l'exemple suivant.

private void Button_Click(object sender, RoutedEventArgs e)
{
    // Create a window and make the current window its owner
    var ownedWindow = new ChildWindow1();
    ownedWindow.Owner = this;
    ownedWindow.Show();
}
Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
    ' Create a window and make the current window its owner
    Dim ownedWindow As New ChildWindow1
    ownedWindow.Owner = Me
    ownedWindow.Show()
End Sub

Une fois la propriété établie :

  • La fenêtre détenue peut référencer sa fenêtre propriétaire en inspectant la valeur de sa Owner propriété.
  • La fenêtre propriétaire peut découvrir toutes les fenêtres qu’elle possède en inspectant la valeur de sa OwnedWindows propriété.

Activation de fenêtre

Lorsqu’une fenêtre est ouverte pour la première fois, elle devient la fenêtre active. La fenêtre active est la fenêtre qui capture actuellement l’entrée utilisateur, telle que les traits de touche et les clics de souris. Lorsqu’une fenêtre devient active, elle déclenche l’événement Activated .

Notes

Lorsqu’une fenêtre est ouverte pour la première fois, les événements et ContentRendered les Loaded événements ne sont déclenchés qu’une fois l’événement Activated déclenché. À l’esprit, une fenêtre peut être considérée comme ouverte lorsqu’elle ContentRendered est déclenchée.

Une fois qu’une fenêtre est active, un utilisateur peut activer une autre fenêtre de la même application ou activer une autre application. Lorsque cela se produit, la fenêtre active devient 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, la fenêtre redevient active et Activated est déclenchée.

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

<Window x:Class="WindowsOverview.CustomMediaPlayerWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Activated="Window_Activated"
        Deactivated="Window_Deactivated"
        Title="CustomMediaPlayerWindow" Height="450" Width="800">
    <Grid>
        <MediaElement x:Name="mediaElement" Stretch="Fill"
                      LoadedBehavior="Manual" Source="numbers.mp4" />
    </Grid>
</Window>

Le code suivant est le code-behind pour le code XAML.

using System;
using System.Windows;

namespace WindowsOverview
{
    public partial class CustomMediaPlayerWindow : Window
    {
        public CustomMediaPlayerWindow() =>
            InitializeComponent();

        private void Window_Activated(object sender, EventArgs e)
        {
            // Continue playing media if window is activated
            mediaElement.Play();
        }

        private void Window_Deactivated(object sender, EventArgs e)
        {
            // Pause playing if media is being played and window is deactivated
            mediaElement.Pause();
        }
    }
}
Public Class CustomMediaPlayerWindow
    Private Sub Window_Activated(sender As Object, e As EventArgs)
        ' Continue playing media if window Is activated
        mediaElement.Play()
    End Sub

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

D’autres types d’application peuvent toujours exécuter du code en arrière-plan quand une fenêtre est désactivée. Par exemple, un client d’e-mail peut continuer à interroger le serveur d’e-mail pendant que l’utilisateur utilise d’autres applications. Les applications comme celles-ci fournissent souvent un comportement différent ou supplémentaire pendant que la fenêtre principale est désactivée. Pour un programme de messagerie, cela peut signifier l’ajout du nouvel élément de courrier à la boîte de réception et l’ajout d’une icône de notification à la barre d’état système. Une icône de notification doit être affichée uniquement lorsque la fenêtre de messagerie n’est pas active, ce qui est déterminé par l’inspection de la IsActive propriété.

Si une tâche en arrière-plan est terminée, une fenêtre peut souhaiter avertir l’utilisateur de manière plus urgente en appelant Activate la méthode. Si l’utilisateur interagit avec une autre application activée lorsqu’elle Activate est appelée, le bouton de la barre des tâches de la fenêtre clignote. Toutefois, si un utilisateur interagit avec l’application actuelle, l’appel Activate amène la fenêtre au premier plan.

Notes

Vous pouvez gérer l’activation de l’étendue de l’application à l’aide des événements et Application.Deactivated des Application.Activated événements.

Prévention de l’activation de fenêtre

Il existe des scénarios où les fenêtres ne doivent pas être activées lorsqu’elles sont affichées, telles que les fenêtres de conversation d’une application de conversation ou les fenêtres de notification d’une application de messagerie électronique.

Si votre application dispose d’une fenêtre qui ne doit pas être activée lorsqu’elle est affichée, vous pouvez définir sa ShowActivated propriété false sur avant d’appeler la méthode pour la Show première fois. En conséquence :

  • La fenêtre n’est pas activée.
  • L’événement de la Activated fenêtre n’est pas déclenché.
  • La fenêtre déjà activée reste activée.

Toutefois, la fenêtre est activée dès que l’utilisateur clique sur la zone cliente ou non cliente. Dans ce cas :

  • La fenêtre est activée.
  • L’événement de la Activated fenêtre est déclenché.
  • La fenêtre qui était activée est désactivée.
  • Les événements et Activated les fenêtres sont ensuite déclenchés comme prévu en réponse aux actions de Deactivated l’utilisateur.

Fermeture d’une fenêtre

Quand un utilisateur ferme une fenêtre, celle-ci cesse d’exister. Une fois qu’une fenêtre est fermée, elle ne peut pas être rouverte. Vous pouvez fermer une fenêtre à l’aide d’éléments de la zone non cliente, notamment :

  • Élément Fermer du menu Système .
  • Appuyez sur Alt + F4.
  • Appuyez sur le bouton Fermer .
  • Appuyer sur Échap lorsqu’un bouton a la IsCancel propriété définie true sur une fenêtre modale.

Vous pouvez fournir davantage de mécanismes à la zone cliente pour fermer une fenêtre, dont les plus courantes incluent les éléments suivants :

  • Élément Exit dans le menu Fichier , généralement pour les fenêtres d’application principales.
  • Élément Fermer dans le menu Fichier , généralement dans une fenêtre d’application secondaire.
  • Bouton Annuler , généralement dans une boîte de dialogue modale.
  • Bouton Fermer , généralement dans une boîte de dialogue sans mode.

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

<Window x:Class="WindowsOverview.ClosingWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="ClosingWindow" Height="450" Width="800">
    <StackPanel>
        <Menu>
            <MenuItem Header="_File">
                <MenuItem Header="E_xit" Click="fileExitMenuItem_Click" />
            </MenuItem>
        </Menu>
    </StackPanel>
</Window>

Le code suivant est le code-behind pour le code XAML.

using System.Windows;

namespace WindowsOverview
{
    public partial class ClosingWindow : Window
    {
        public ClosingWindow() =>
            InitializeComponent();

        private void fileExitMenuItem_Click(object sender, RoutedEventArgs e)
        {
            // Close the current window
            this.Close();
        }
    }
}
Public Class ClosingWindow
    Private Sub fileExitMenuItem_Click(sender As Object, e As RoutedEventArgs)
        ' Close the current window
        Me.Close()
    End Sub
End Class

Notes

Une application peut être configurée pour s’arrêter automatiquement lorsque la fenêtre principale de l’application se ferme (voir MainWindow) ou la dernière fenêtre se ferme. Pour plus d’informations, consultez ShutdownMode.

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

Important

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

Annuler la fermeture de fenêtre

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

Closing est déclenché avant la fermeture de la fenêtre et fournit un mécanisme par lequel la fermeture de fenêtre peut être évitée. Bien souvent, la fermeture d’une fenêtre est nécessaire si elle contient des données qui ont été modifiées. Dans ce cas, l’événement Closing peut être géré pour déterminer si les données sont incorrectes et, le cas échéant, demander à l’utilisateur s’il faut continuer à fermer la fenêtre sans enregistrer les données ou annuler la fermeture de la fenêtre. L’exemple suivant montre les aspects clés de la gestion Closing.

<Window x:Class="WindowsOverview.DataWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="DataWindow" Height="450" Width="800"
        Closing="Window_Closing">
    <Grid>
        <TextBox x:Name="documentTextBox" TextChanged="documentTextBox_TextChanged" />
    </Grid>
</Window>

Le code suivant est le code-behind pour le code XAML.

using System.Windows;
using System.Windows.Controls;

namespace WindowsOverview
{
    public partial class DataWindow : Window
    {
        private bool _isDataDirty;

        public DataWindow() =>
            InitializeComponent();

        private void documentTextBox_TextChanged(object sender, TextChangedEventArgs e) =>
            _isDataDirty = true;

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            // If data is dirty, prompt user and ask for a response
            if (_isDataDirty)
            {
                var result = MessageBox.Show("Document has changed. Close without saving?",
                                             "Question",
                                             MessageBoxButton.YesNo);

                // User doesn't want to close, cancel closure
                if (result == MessageBoxResult.No)
                    e.Cancel = true;
            }
        }
    }
}
Public Class DataWindow

    Private _isDataDirty As Boolean

    Private Sub documentTextBox_TextChanged(sender As Object, e As TextChangedEventArgs)
        _isDataDirty = True
    End Sub

    Private Sub Window_Closing(sender As Object, e As ComponentModel.CancelEventArgs)

        ' If data is dirty, prompt user and ask for a response
        If _isDataDirty Then
            Dim result = MessageBox.Show("Document has changed. Close without saving?",
                                         "Question",
                                         MessageBoxButton.YesNo)

            ' User doesn't want to close, cancel closure
            If result = MessageBoxResult.No Then
                e.Cancel = True
            End If
        End If

    End Sub
End Class

Le Closing gestionnaire d’événements est passé à un CancelEventArgs, qui implémente la Cancel propriété que vous avez définie pour true empêcher la fermeture d’une fenêtre.

Si Closing elle n’est pas gérée ou si elle est gérée mais non annulée, la fenêtre se ferme. Juste avant qu’une fenêtre se ferme, Closed elle est levée. À ce stade, une fenêtre ne peut pas être empêchée de se fermer.

Événements de durée de vie des fenêtres

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

Diagram that shows events in a window's lifetime.

L’illustration suivante montre la séquence des événements principaux dans la durée de vie d’une fenêtre affichée sans activation (ShowActivated définie false avant l’affichage de la fenêtre) :

Diagram that shows events in a window's lifetime without activation.

Emplacement de la fenêtre

Quand 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 inspectant respectivement les propriétés et Top les Left propriétés. Définissez ces propriétés pour modifier l’emplacement de la fenêtre.

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

Si l’emplacement de démarrage est spécifié comme Manual, et que les propriétés et Top les Left propriétés n’ont pas été définies, Window demandez au système d’exploitation qu’un emplacement s’affiche.

Fenêtres les plus hauts et ordre de plan

Outre un emplacement dans les dimensions x et y, une fenêtre a également un emplacement dans la dimension z, qui détermine sa position verticale par rapport à d’autres fenêtres. Il s’agit de l’ordre de plan de la fenêtre, et il existe deux types : l’ordre de plan normal et l’ordre z le plus élevé . L’emplacement d’une fenêtre dans l’ordre z normal est déterminé par s’il est actuellement actif 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. De plus, les fenêtres dans l’ordre de plan le plus haut sont toujours situées au-dessus des fenêtres dans l’ordre de plan normal. Une fenêtre se trouve dans l’ordre de plan supérieur en définissant sa Topmost propriété truesur .

Dans chaque type d’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

En plus d’avoir un emplacement de bureau, une fenêtre a une taille déterminée par plusieurs propriétés, y compris les différentes propriétés de largeur et de hauteur et SizeToContent.

MinWidth, Widthet MaxWidth sont utilisés pour gérer la plage de largeurs qu’une fenêtre peut avoir pendant sa durée de vie.

<Window 
    xmlns="http://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, Heightet MaxHeight.

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

Étant donné que les différentes valeurs de largeur et de hauteur spécifient chacune une plage, il est possible que la largeur et la hauteur d’une fenêtre redimensionnable se trouvent n’importe où dans la plage spécifiée pour la dimension respective. Pour détecter respectivement sa largeur et sa hauteur actuelles, inspectez ActualWidth et ActualHeight, respectivement.

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

L’exemple suivant montre une fenêtre qui s’ajuste automatiquement en fonction de son contenu, verticalement et horizontalement, au moment où elle s’affiche pour la première fois.

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

L’exemple suivant montre comment définir la propriété dans le SizeToContent code pour spécifier comment une fenêtre se redimensionne pour adapter son contenu.

// Manually alter window height and width
this.SizeToContent = SizeToContent.Manual;

// Automatically resize width relative to content
this.SizeToContent = SizeToContent.Width;

// Automatically resize height relative to content
this.SizeToContent = SizeToContent.Height;

// Automatically resize height and width relative to content
this.SizeToContent = SizeToContent.WidthAndHeight;
' Manually alter window height and width
Me.SizeToContent = SizeToContent.Manual

' Automatically resize width relative to content
Me.SizeToContent = SizeToContent.Width

' Automatically resize height relative to content
Me.SizeToContent = SizeToContent.Height

' Automatically resize height and width relative to content
Me.SizeToContent = SizeToContent.WidthAndHeight

Ordre de priorité pour les 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 d’une fenêtre redimensionnable. Pour garantir qu’une plage valide est conservée, Window évalue les valeurs des propriétés de taille à l’aide 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, qui est gérée avec la WindowState propriété.

État de la fenêtre

Au cours de sa durée de vie, une fenêtre redimensionnable peut avoir trois états : normal, réduit et agrandi. Une fenêtre avec un état normal est l’état par défaut d’une fenêtre. Une fenêtre avec cet état permet à un utilisateur de le déplacer et de le redimensionner à l’aide d’une poignée de redimensionnement ou de la bordure, s’il est resizable.

Une fenêtre avec un état réduit s’réduit à son bouton de barre de tâches s’il ShowInTaskbar est défini truesur ; sinon, il s’réduit à la taille la plus petite possible qu’il peut être et se déplace vers 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 redimensionnement. Toutefois, une fenêtre réduite qui n’est pas affichée dans la barre des tâches peut être déplacée partout sur le Bureau.

Une fenêtre avec un état agrandi s’étend à la taille maximale qu’elle peut être, qui ne sera aussi grande que son MaxWidth, MaxHeightet SizeToContent les propriétés dictent. Comme une fenêtre réduite, une fenêtre agrandie ne peut pas être redimensionnée à l’aide d’une poignée de redimensionnement ou en faisant glisser la bordure.

Notes

Les valeurs des Topvaleurs , , Widthet LeftHeight propriétés d’une fenêtre représentent toujours les valeurs de l’état normal, même lorsque la fenêtre est actuellement agrandie ou réduite.

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

L’exemple suivant montre comment créer une fenêtre agrandie quand elle s’ouvre.

<Window 
    xmlns="http://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 resizable est affichée, les utilisateurs peuvent appuyer sur les boutons réduire, maximiser et restaurer sur la barre de titre de la fenêtre pour modifier l’état de la fenêtre.

Apparence de la fenêtre

Vous pouvez changer l’apparence de la zone cliente d’une fenêtre en lui ajoutant un contenu spécifique, par exemple des boutons, des étiquettes et des zones de texte. Pour configurer la zone non cliente, Window fournit plusieurs propriétés, notamment Icon pour définir l’icône d’une fenêtre et Title définir son titre.

Vous pouvez également changer 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, ainsi que son affichage ou non sous forme de bouton dans la barre des tâches du Bureau.

Redimensionner le mode

Selon la WindowStyle propriété, vous pouvez contrôler si et comment les utilisateurs redimensionnent la fenêtre. Le style de fenêtre affecte les éléments suivants :

  • Autoriser ou interdire le redimensionnement en faisant glisser la bordure de la fenêtre avec la souris.
  • Indique si les boutons Réduire, Agrandir et Fermer apparaissent sur la zone non cliente.
  • Indique si les boutons Réduire, Agrandir et Fermer sont activés.

Vous pouvez configurer la façon dont une fenêtre se redimensionne en définissant sa ResizeMode propriété, qui peut être l’une des valeurs d’énumération suivantes ResizeMode :

Comme avec WindowStyle, le mode de redimensionnement d’une fenêtre est peu susceptible de changer pendant sa durée de vie, ce qui signifie que vous le définirez probablement à partir du balisage XAML.

<Window 
    xmlns="http://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 inspectant la WindowState propriété.

Style de fenêtre

La bordure exposée à partir de la zone non cliente d’une fenêtre convient à la plupart des applications. Toutefois, selon les circonstances, il arrive que d’autres types de bordure (voire aucune bordure) soient nécessaires, en fonction du type de fenêtre.

Pour contrôler le type de bordure d’une fenêtre, vous définissez sa WindowStyle propriété avec l’une des valeurs suivantes de l’énumération WindowStyle :

L’effet de l’application d’un style de fenêtre est illustré dans l’image suivante :

Screenshot that shows how WindowStyle affects a window in WPF.

Notez que l’image ci-dessus ne présente aucune différence notable entre SingleBorderWindow et ThreeDBorderWindow. De retour dans Windows XP, a affecté la façon dont la fenêtre a été dessinée, ThreeDBorderWindow en ajoutant une bordure 3D à la zone cliente. À compter de Windows 7, les différences entre les deux styles sont minimales.

Vous pouvez définir WindowStyle à l’aide du balisage XAML ou du code. Étant donné qu’il est peu probable qu’il change pendant la durée de vie d’une fenêtre, vous allez probablement le configurer à l’aide du balisage XAML.

<Window 
    xmlns="http://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 qui WindowStyle vous permettent d’avoir ne sont pas suffisants. Par exemple, vous pouvez créer une application avec une bordure non rectangulaire, comme Microsoft Lecteur Windows Media l’utilise.

Par exemple, tenez compte de la fenêtre de bulles vocales affichée dans l’image suivante :

Screenshot of a WPF window that has a clipped area and custom shape.

Ce type de fenêtre peut être créé en définissant la propriété Nonesur , et à l’aide WindowStyle d’une prise en charge spéciale qui Window a pour transparence.

<Window x:Class="WindowsOverview.ClippedWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="ClippedWindow" SizeToContent="WidthAndHeight"
        WindowStyle="None" AllowsTransparency="True" Background="Transparent">
    <Grid Margin="20">
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
            <RowDefinition Height="20"/>
        </Grid.RowDefinitions>

        <Rectangle Stroke="#FF000000" RadiusX="10" RadiusY="10"/>
        <Path Fill="White" Stretch="Fill" Stroke="#FF000000" HorizontalAlignment="Left" Margin="15,-5.597,0,-0.003" Width="30" Grid.Row="1" Data="M22.166642,154.45381 L29.999666,187.66699 40.791059,154.54395"/>
        <Rectangle Fill="White" RadiusX="10" RadiusY="10" Margin="1"/>
        
        <TextBlock HorizontalAlignment="Left" VerticalAlignment="Center" FontSize="25" Text="Greetings!" TextWrapping="Wrap" Margin="5,5,50,5"/>
        <Button HorizontalAlignment="Right" VerticalAlignment="Top" Background="Transparent" BorderBrush="{x:Null}" Foreground="Red" Content="❌" FontSize="15" />

        <Grid.Effect>
            <DropShadowEffect BlurRadius="10" ShadowDepth="3" Color="LightBlue"/>
        </Grid.Effect>
    </Grid>
</Window>

Cette combinaison de valeurs indique à la fenêtre de rendre transparent. Dans cet état, les boutons d’ornement de zone non cliente de la fenêtre ne peuvent pas être utilisés et vous devez fournir votre propre.

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. Certains types de fenêtres n’ont pas de bouton barre de tâches, comme les boîtes de dialogue, les boîtes de dialogue ou les fenêtres avec la WindowStyle propriété définie sur ToolWindow. Vous pouvez contrôler si le bouton de barre des tâches d’une fenêtre est affiché en définissant la ShowInTaskbar propriété, par true défaut.

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

Autres types de fenêtres

NavigationWindow est une fenêtre conçue pour héberger du contenu navigable.

Les boîtes de dialogue sont des fenêtres souvent utilisées pour rassembler des informations fournies par un utilisateur afin d’exécuter une fonction. Par exemple, lorsqu’un utilisateur souhaite ouvrir un fichier, la boîte de dialogue Ouvrir un fichier s’affiche par une application pour obtenir le nom de fichier de l’utilisateur. Pour plus d’informations, consultez Vue d’ensemble des boîtes de dialogue.

Voir aussi