Fenêtre

La classe .NET Multiplateform App UI (.NET MAUI) Window offre la possibilité de créer, configurer, afficher et gérer plusieurs fenêtres.

Window définit les propriétés suivantes :

• FlowDirection, de type FlowDirection, définit la direction dans laquelle l’élément d’interface utilisateur de la fenêtre est disposé.
• Height, de type double, spécifie la hauteur de la fenêtre sur Windows.
• MaximumHeight, de type double, représente la hauteur maximale de la fenêtre sur les plateformes de bureau. Les valeurs valides sont comprises entre 0 et double.PositiveInfinity.
• MaximumWidth, de type double, représente la largeur maximale de la fenêtre sur les plateformes de bureau. Les valeurs valides sont comprises entre 0 et double.PositiveInfinity.
• MinimumHeight, de type double, représente la hauteur minimale de la fenêtre sur les plateformes de bureau. Les valeurs valides sont comprises entre 0 et double.PositiveInfinity.
• MinimumWidth, de type double, représente la largeur minimale de la fenêtre sur les plateformes de bureau. Les valeurs valides sont comprises entre 0 et double.PositiveInfinity.
• Overlays, de type IReadOnlyCollection<IWindowOverlay>, représente la collection de superpositions de fenêtres.
• Page, de type Page, indique la page affichée par la fenêtre. Cette propriété est la propriété de contenu de la Window classe et n’a donc pas besoin d’être définie explicitement.
• Title, de type string, représente le titre de la fenêtre.
• Width, de type double, spécifie la largeur de la fenêtre sur Windows.
• X, de type double, spécifie la coordonnée X de la fenêtre sur Windows.
• Y, de type double, spécifie la coordonnée Y de la fenêtre sur Windows.

Ces propriétés, à l’exception de la propriété Overlays, sont sauvegardées par des objets BindableProperty, ce qui signifie qu’elles peuvent être des cibles de liaisons de données et stylisées.

La Window classe définit les événements suivants :

• Created, qui est déclenché lors de la création de la fenêtre.
• Resumed, qui est déclenché lorsque la fenêtre est reprise à partir d’un état de veille.
• Activated, qui est déclenché lorsque la fenêtre est activée.
• Deactivated, qui est déclenché lorsque la fenêtre est désactivée.
• Stopped, qui est déclenché lorsque la fenêtre est arrêtée.
• Destroying, qui est déclenché lorsque la fenêtre est détruite.
• SizeChanged, qui est déclenché sur les plateformes de bureau lorsque la fenêtre change de taille.
• Backgrounding, avec un objet associé BackgroundingEventArgs , qui est déclenché sur iOS et Mac Catalyst lorsque la fenêtre est fermée ou entre dans un état d’arrière-plan. Cet événement peut être utilisé pour conserver n’importe quel string état sur la State propriété de l’objet BackgroundingEventArgs , que le système d’exploitation conserve jusqu’à ce qu’il soit temps de reprendre la fenêtre. Lorsque la fenêtre reprend l’état est fourni via l’argument IActivationState de la CreateWindow méthode.
• DisplayDensityChanged, avec un objet DisplayDensityChangedEventArgs associé, qui est déclenché sur Android et Windows lorsque les points effectifs par pouce (PPP) pour la fenêtre ont changé.

Pour plus d’informations sur les événements de cycle de vie et leurs remplacements associés, consultez cycle de vie des applications.

La Window classe définit également les événements de navigation modale suivants :

• ModalPopped, avec ModalPoppedEventArgs, qui est déclenché lorsqu’une vue a été fermée de manière modale.
• ModalPopping, avec ModalPoppingEventArgs, qui est déclenché lors du retrait d'une vue présentée de manière modale.
• ModalPushed, avec ModalPushedEventArgs, qui est déclenché après qu'une vue a été affichée de manière modale.
• ModalPushing, avec ModalPushingEventArgs, qui est déclenché lorsqu'une vue est affichée de manière modale.
• PopCanceled, qui est déclenché lorsqu’une fenêtre contextuelle modale est annulée.

La VisualElement classe a une Window propriété qui expose l’objet parent Window . Cette propriété est accessible à partir de n’importe quelle page, mise en page ou vue, pour manipuler des Window objets.

Créer une fenêtre

Par défaut, votre application MAUI .NET remplace la CreateWindow méthode de votre App classe pour créer un Window objet :

namespace MyMauiApp
{
    public partial class App : Application
    {
        public App()
        {
            InitializeComponent();
        }

        protected override Window CreateWindow(IActivationState? activationState)
        {
            return new Window(new AppShell());
        }
    }
}

La Window classe a un constructeur par défaut et un constructeur qui accepte un Page argument, qui représente la page racine de l’application.

En outre, vous pouvez également créer votre propre Windowobjet dérivé :

namespace MyMauiApp
{
    public class MyWindow : Window
    {
        public MyWindow() : base()
        {
        }

        public MyWindow(Page page) : base(page)
        {
        }

        // Override Window methods
    }
}

La classe dérivée Window peut ensuite être consommée en créant un objet MyWindow dans la surcharge CreateWindow de votre classe App.

Quel que soit le mode de création de votre Window objet, il sera le parent de la page racine de votre application.

Prise en charge de plusieurs fenêtres

Plusieurs fenêtres peuvent être ouvertes simultanément sur Android, iOS sur iPad (iPadOS), Mac Catalyst et Windows. Pour ce faire, créez un Window objet et ouvrez-le à l’aide de la OpenWindow méthode sur l’objet Application :

Window secondWindow = new Window(new MyPage());
Application.Current?.OpenWindow(secondWindow);

La Application.Current.Windows collection, de type IReadOnlyList<Window> , gère les références à tous les Window objets inscrits auprès de l’objet Application .

Une fenêtre spécifique peut être mise en avant sur Mac Catalyst et Windows avec la Application.Current.ActivateWindow méthode :

Application.Current?.ActivateWindow(secondWindow);

Windows peut être fermé avec la Application.Current.CloseWindow méthode :

// Close a specific window
Application.Current?.CloseWindow(secondWindow);

// Close the active window
Application.Current?.CloseWindow(GetParentWindow());

Important

La fonctionnalité multi-fenêtre fonctionne sur Windows sans configuration supplémentaire. Toutefois, une configuration supplémentaire est requise sur Android, iPadOS et Mac Catalyst.

Configuration Android

Pour utiliser la prise en charge du multi-fenêtrage sur Android, vous devez modifier le mode de lancement MainActivity dans Plateformes > Android > MainActivity.cs de LaunchMode.SingleTop à LaunchMode.Multiple.

using Android.App;
using Android.Content.PM;
using Android.OS;

namespace MyMauiApp;

[Activity(Theme = "@style/Maui.SplashTheme", MainLauncher = true, LaunchMode = LaunchMode.Multiple, ...)]
public class MainActivity : MauiAppCompatActivity
{
}

Configuration iPadOS et macOS

Pour utiliser la prise en charge multi-fenêtre sur iPadOS et Mac Catalyst, ajoutez une classe nommée SceneDelegate aux dossiers Plateformes iOS et Plateformes >> MacCatalyst :

using Foundation;
using Microsoft.Maui;
using UIKit;

namespace MyMauiApp;

[Register("SceneDelegate")]
public class SceneDelegate : MauiUISceneDelegate
{
}

Ensuite, dans l’éditeur XML, ouvrez le fichier Platforms > iOS > Info.plist et le fichier Platforms > MacCatalyst > Info.plist et ajoutez le code XML suivant à la fin de chaque fichier :

<key>UIApplicationSceneManifest</key>
<dict>
  <key>UIApplicationSupportsMultipleScenes</key>
  <true/>
  <key>UISceneConfigurations</key>
  <dict>
    <key>UIWindowSceneSessionRoleApplication</key>
    <array>
      <dict>
        <key>UISceneConfigurationName</key>
        <string>__MAUI_DEFAULT_SCENE_CONFIGURATION__</string>
        <key>UISceneDelegateClassName</key>
        <string>SceneDelegate</string>
      </dict>
    </array>
  </dict>
</dict>

Important

La prise en charge multi-fenêtre ne fonctionne pas sur iOS pour iPhone.

Position et taille d’une fenêtre

La position et la taille d'une fenêtre peuvent être définies par programmation pour une application .NET MAUI sur Mac Catalyst et Windows en définissant les propriétés X, Y, Width et Height sur un objet Window.

Par exemple, pour définir la position et la taille de la fenêtre lors du lancement, vous devez surcharger la méthode CreateWindow dans votre classe App et définir les propriétés X, Y, Width et Height sur un objet Window :

public partial class App : Application
{
    public App()
    {
        InitializeComponent();
    }

    protected override Window CreateWindow(IActivationState activationState) =>
        new Window(new AppShell())
        {
            Width = 700,
            Height = 500,
            X = 100,
            Y = 100
        };
}

Une fenêtre peut également être positionnée et dimensionnée en accédant à la Window propriété à partir de n’importe quelle page, mise en page ou vue. Par exemple, le code suivant montre comment positionner une fenêtre au centre de l’écran :

// Get display size
var displayInfo = DeviceDisplay.Current.MainDisplayInfo;

// Center the window
Window.X = (displayInfo.Width / displayInfo.Density - Window.Width) / 2;
Window.Y = (displayInfo.Height / displayInfo.Density - Window.Height) / 2;

Pour plus d’informations sur l’obtention des métriques d’écran de l’appareil, consultez les informations d’affichage de l’appareil.

Dissocier la gestion des fenêtres à partir de la classe App

La gestion des fenêtres peut être découplée de la App classe en créant une classe qui implémente l’interface IWindowCreator et en ajoutant votre code de gestion de fenêtre dans la CreateWindow méthode :

public class WindowCreator : IWindowCreator
{
    public Window CreateWindow(Application app, IActivationState activationState)
    {
        var window = new Window(new ContentPage
        {
            Content = new Grid
            {
                new Label
                {
                    Text = "Hello from IWindowCreator",
                    HorizontalOptions = LayoutOptions.Center,
                    VerticalOptions = LayoutOptions.Center
                }
            }
        });

        return window;
    }
}

Ensuite, dans la MauiProgram classe, vous devez inscrire votre type de gestion de fenêtre en tant que dépendance dans le conteneur de service de l’application :

builder.Services.AddSingleton<IWindowCreator, WindowCreator>();

Important

Vérifiez que votre code d’inscription spécifie l’interface IWindowCreator ainsi que son type concret.

Vérifiez ensuite que votre App classe ne définit pas la MainPage propriété :

public partial class App : Application
{
    public App()
    {
        InitializeComponent();
    }
}

À condition que l’interface IWindowCreator et son type concret aient été inscrits auprès du conteneur de service de l’application et que la MainPage propriété de la Application classe n’est pas définie, votre type inscrit sera utilisé pour créer le Window.

Activer ou désactiver la réduction et l’agrandissement des boutons sur Windows

Sur Windows, vous pouvez activer ou désactiver les boutons réduire et agrandir sur une fenêtre. Pour ce faire, récupérez la fenêtre WinUI sous-jacente et ajustez ses propriétés de présentateur.

L’exemple suivant désactive à la fois les boutons réduire et agrandir :

#if WINDOWS
using Microsoft.Maui.Platform; // MauiWinUIWindow
using Microsoft.UI.Windowing;  // AppWindow, OverlappedPresenter

public static void ConfigureWindowButtons(Window window)
{
    var nativeWindow = (MauiWinUIWindow)window.Handler.PlatformView;
    var appWindow = nativeWindow.AppWindow;

    if (appWindow.Presenter is OverlappedPresenter presenter)
    {
        presenter.IsMinimizable = false;
        presenter.IsMaximizable = false;
    }
}
#endif

Appelez ConfigureWindowButtons au démarrage de l’application (par exemple, après avoir créé le Window dans CreateWindow) ou lors de l'affichage d'une fenêtre secondaire.

Note

Ces propriétés s’appliquent uniquement sur le bureau Windows. D’autres plateformes ignorent ce chemin de code. Pour réactiver les boutons, définissez IsMinimizable et IsMaximizable à true.