Démo Delphi WinUI 3

Hier, à l’occasion du 27e anniversaire de Delphi, Embarcadero a publié une démo WinUI 3 que j’ai présentée lors du webinaire anniversaire. Voici l’annonce officielle ainsi que quelques informations techniques supplémentaires. La démo est disponible dans GetIt.

introduction

Le SDK Windows App de Microsoft (anciennement connu sous le nom de Project Reunion) inclut un nouveau framework d’interface utilisateur natif appelé WinUI 3. WinUI 3 est le framework d’interface utilisateur actuel dans l’architecture WinRT (Windows Runtime) et il est disponible pour les applications packagées (via des conteneurs APPX ou MSIX) et les applications GUI non packagées (c’est-à-dire les applications natives Win32/Win64 standard, comme celles créées avec Delphi et RAD Studio. Cette référence aux applications packagées n’a rien à voir avec les packages Delphi.

Gardez également à l’esprit que le SDK de l’application Windows est un ensemble d’outils différent du SDK Windows du même nom, disponible depuis longtemps dans le cadre de l’installation de Delphi.
L’exemple de projet SampleWinRT est destiné à montrer comment construire une application graphique Delphi simple uniquement à partir du framework WinUI 3 (1.0) de Microsoft, publié en novembre 2021. Les versions préliminaires de WinUI3 nécessitaient que l’application soit déployée en tant qu’application packagée Windows, mais WinUI 3 (1.0) supprime cette restriction, ce qui signifie que vous pouvez créer une application WinUI 3 dans Delphi en tant qu’application standard.

Vous pouvez en savoir plus sur WinUI 3 ici : https://docs.microsoft.com/en-us/windows/apps/winui/winui3 
Vous pouvez en savoir plus sur le SDK d’application Windows ici : https://docs.microsoft.com /en-us/windows/apps/windows-app-sdk/

La démo est fournie avec des versions mises à jour des unités d’importation WinRT Delphi RTL, pour prendre en charge la version 1.0 de WinUI 3. La version actuelle de Delphi 11 Alexandria est livrée avec un ensemble plus ancien des mêmes unités d’importation.

Prérequis : programme d’installation d’exécution de l’application Windows et DLL du chargeur d’exécution de l’application Windows

Pour créer et déployer une application non emballée, vous avez besoin de quelques éléments, comme indiqué sur https://docs.microsoft.com/en-us/windows/apps/windows-app-sdk/deploy-unpackaged-apps

1. Tout d’abord, vous avez besoin du programme d’ installation de Windows App SDK , que vous pouvez obtenir à partir d’un lien de téléchargement sur la page Microsoft susmentionnée, ou téléchargez-le depuis https://aka.ms/windowsappsdk/1.0-stable/msix-installer. Cela vous donne l’archive de fichiers redistribuable, actuellement appelée Microsoft.WindowsAppRuntime.Redist.1.0.0.zip, qui contient les programmes d’installation pour les plates-formes x86 et x64 (toutes deux appelées WindowsAppRuntimeInstaller.exe) dans des dossiers nommés de manière sensée.

L’exécution du programme d’installation (avec des privilèges élevés) garantira que vous avez installé Windows App Runtime – il va dans des dossiers cachés sous C:Program FilesWindowsApps, par exemple la version x86 peut être installée dans C:Program FilesWindowsAppsMicrosoft.WindowsAppRuntime.1.0_0.319.455 .0_x86__8wekyb3d8bbwe.

2. La deuxième chose dont vous avez besoin est la DLL du chargeur Windows App Runtime , Microsoft.WindowsAppRuntime.Bootstrap.dll. Ce fichier est obtenu à partir du package Windows App SDK NuGet, actuellement Microsoft.WindowsAppSDK.1.0.0.nupkg, qui est disponible à partir de https://www.nuget.org/packages/Microsoft.WindowsAppSDK dans le dossier runtimeswin10-x86native ou runtimeswin10-x64native. Cette DLL doit être placée à côté de votre exécutable afin d’être localisée au démarrage de l’application lorsque les API concernées sont appelées. La DLL du chargeur (ou DLL d’amorçage) est responsable de la localisation d’une version appropriée de Windows App Runtime, qui implémente WinUI 3, en fonction des valeurs de version transmises à son API de démarrage.

Remarque : si vous avez utilisé le support du composant TEdgeBrower de Delphi, qui encapsule une autre fonctionnalité du SDK d’application Windows, vous remarquerez peut-être une similitude dans les exigences pour un environnement d’exécution (également requis par les utilisateurs finaux) et un SDK avec une DLL chargée redistribuable

Téléchargement de la démo

La démo Delphi WinUI 3 est disponible sur GetIt pour les clients RAD Studio 11 Alexandria. En l’installant, le code source de la démo et des fichiers de bibliothèque requis est installé avec un fichier Lisez-moi avec un contenu similaire à ce billet de blog. Voici le package GetIt :

Présentation de la démo

L’application de démonstration est conçue comme une application de console, pas par nécessité, mais pour que des informations puissent être écrites dans la fenêtre de la console au fur et à mesure que l’application progresse, offrant également un moyen d’afficher des messages d’erreur (tels que des dépendances manquantes)

Remarque : WinUI 3 vous oblige à exécuter le processus sans privilèges élevés. En tant que telle, la démo vérifie cela et se termine avec un simple message si elle trouve des privilèges élevés. Sans cette vérification en place, WinUI 3 plante l’application d’une manière apparemment sans grâce.

En supposant que nous réussissions la vérification des privilèges, l’application appelle l’API d’initialisation dans la DLL du chargeur, MddBootstrapInitialize , et si cela localise et démarre le Windows App Runtime, l’application procède ensuite à une initialisation supplémentaire. Avant de quitter l’application appelle MddBootstrapShutdown pour nettoyer :

[crayon-673f4c7fcf8f8877814887/]
Comme vous pouvez le voir, la version du SDK et les versions du package d’exécution sont empruntées à un fichier d’en-tête (.h) situé dans le package Windows App SDK NuGet
Dans Main, nous appelons la méthode Start statique de l’objet Application WinUI 3 – voir https:// docs.microsoft.com/en-us/windows/winui/api/microsoft.ui.xaml.application.start . Cela prend un rappel qui sera exécuté lors de l’initialisation de l’application, nous permettant de configurer les choses comme nous le souhaitons. Fortuitement, les rappels WinRT (y compris les rappels WinUI 3) ont la même implémentation qu’une méthode anonyme Delphi, nous utilisons donc une méthode anonyme pour configurer le gestionnaire d’ événements OnLaunched de notre application.

Dans WinUI 3 , OnLaunched n’est pas réellement un gestionnaire d’événements. Au lieu de cela, OnLaunched – https://docs.microsoft.com/en-us/windows/winui/api/microsoft.ui.xaml.application.onlaunched – est une méthode que nous sommes censés remplacer dans une classe qui hérite de WinUI Classe d’applications. Comment faire face à cette exigence d’hériter d’une classe WinRT de Delphi ?

WinUI nous aide en fournissant un mécanisme que nous pouvons utiliser. Dans un cas comme celui-ci, hériter d’une classe WinUI 3 implique 3 objets :

1) Un objet interne qui donne l’implémentation de base, qui est fournie par WinUI, dans ce cas une implémentation d’application de base. Cet objet interne implémentera une interface qui définit la ou les méthodes pour lesquelles nous fournirons des implémentations ; IApplicationOverrides dans ce cas.

2) Un objet externe (parfois appelé objet de base) qui fournit l’implémentation personnalisée de la ou des méthodes en question. Cet objet externe, que nous fournirons, implémentera également IApplicationOverrides .

3) Un objet wrapper, qui combine l’objet interne et externe, et est fourni par WinUI

Voici le code de Main :

[crayon-673f4c7fcf90a141709250/]
Le code de personnalisation de l’application provient de cette classe :
[crayon-673f4c7fcf90e723174859/]
La méthode OnLaunched est alors libre de faire toute la configuration de l’application requise. Dans ce cas, nous créons et configurons une fenêtre – https://docs.microsoft.com/en-us/windows/winui/api/microsoft.ui.xaml.window et la remplissons avec quelques contrôles, créant l’interface utilisateur suivante :

Regardez dans le code pour tous les détails de ce qui se passe, mais en résumé :

• Nous créons un contrôle StackPanel et le plaçons dans la fenêtre, puis un bouton est créé avec un gestionnaire d’événement Click et ajouté au StackPanel .
• Ensuite, nous utilisons du XAML pour créer un autre StackPanel et un contrôle enfant de bouton, toujours avec un gestionnaire d’événements Click, en ajoutant le StackPanel à la fenêtre. Cela nous donne 2 approches pour atteindre le même objectif.
• Enfin, un peu plus de XAML est utilisé pour créer un Grid et à l’intérieur de celui-ci un TextBlock , qui a ensuite quelques gestionnaires d’événements ajoutés pour OnPointerEntered et OnPointerExited .
• En fin de compte, nous nous retrouvons avec une fenêtre affichant quelques boutons et un bloc de texte. Les boutons peuvent être cliqués pour changer leur légende et le bloc de texte change de couleur lorsque vous déplacez la souris dans et hors de celui-ci.

Notez que pour les contrôles d’interface utilisateur créés dynamiquement (comme le premier bouton), les gestionnaires d’événements peuvent être associés directement, tandis que lorsque les contrôles sont créés en chargeant une configuration XAML, le code doit localiser l’objet correspondant pour lui associer un gestionnaire d’événements.

Remarque : contrairement à C# et C++, la projection de langage pour Delphi n’intègre pas actuellement toutes les différentes interfaces implémentées par les objets WinRT et WinUI 3 dans des classes proxy unifiées, et il y a donc beaucoup plus de travail d’interface en cours que ce ne serait le cas ailleurs.

Et après

Cette démonstration de l’utilisation de Win UI 3 dans une application Delphi 11 packagée ou non est principalement destinée à tous ceux qui souhaitent expérimenter cette nouvelle technologie d’interface utilisateur du point de vue de Delphi. En tant qu’Embarcadero, nous suivons l’évolution de WinUI 3 et planifions comment le prendre en charge à l’avenir. Microsoft a annoncé la prise en charge future de l’hébergement des contrôles WinUI 3 dans un handle de formulaire Windows traditionnel (c’est-à-dire une application VCL ou FMX) via XAML Islands pour Win UI 3 – une fonctionnalité attendue pour la fin 2022, il est donc assez tôt pour nous de discuter un plan pour une intégration plus fluide. Restez à l’écoute.