Gestern, zum 27. Jubiläum von Delphi, hat Embarcadero eine WinUI 3-Demo veröffentlicht, die ich im Jubiläums-Webinar vorgestellt habe. Hier ist die offizielle Ankündigung zusammen mit einigen weiteren technischen Informationen. Die Demo ist in GetIt verfügbar.
Inhaltsverzeichnis
Einführung
Das Windows App SDK von Microsoft (früher bekannt als Project Reunion) enthält ein neues natives UI-Framework namens WinUI 3. WinUI 3 ist das aktuelle UI-Framework in der WinRT-Architektur (Windows Runtime) und ist für gepackte Anwendungen (über APPX- oder MSIX-Container) verfügbar. und nicht gepackte GUI-Anwendungen (d. h. normale Win32/Win64-native Anwendungen, wie sie mit Delphi und RAD Studio erstellt wurden. Dieser Verweis auf gepackte Anwendungen hat nichts mit Delphi-Paketen zu tun.
Denken Sie auch daran, dass das Windows App SDK ein anderer Satz von Tools ist als das gleichnamige Windows SDK, das seit langem als Teil der Delphi-Installation verfügbar ist.
Das Beispielprojekt SampleWinRT soll zeigen, wie eine einfache Delphi-GUI-Anwendung ausschließlich aus dem im November 2021 veröffentlichten WinUI 3 (1.0)-Framework von Microsoft erstellt wird. Vorabversionen von WinUI3 erforderten, dass die Anwendung als Windows-Paketanwendung bereitgestellt wurde. aber WinUI 3 (1.0) hebt diese Einschränkung auf, was bedeutet, dass Sie eine WinUI 3-App in Delphi als reguläre App erstellen können.
Mehr über WinUI 3 finden Sie hier: https://docs.microsoft.com/en-us/windows/apps/winui/winui3
Mehr über das Windows App SDK finden Sie hier: https://docs.microsoft.com /en-us/windows/apps/windows-app-sdk/
Die Demo wird mit aktualisierten Versionen der WinRT-Delphi-RTL-Importeinheiten geliefert, um die Version 1.0 von WinUI 3 zu unterstützen. Die aktuelle Version von Delphi 11 Alexandria wird mit einem älteren Satz derselben Importeinheiten geliefert.
Voraussetzungen: Windows-App-Laufzeitinstallationsprogramm und Windows-App-Laufzeitladeprogramm-DLL
Um eine entpackte App zu erstellen und bereitzustellen, benötigen Sie einige Dinge, wie unter https://docs.microsoft.com/en-us/windows/apps/windows-app-sdk/deploy-unpackaged-apps beschrieben
1. Zunächst benötigen Sie das Windows App SDK-Installationsprogramm , das Sie über einen Download-Link auf der oben genannten Microsoft-Seite erhalten oder von https://aka.ms/windowsappsdk/1.0-stable/msix-installer herunterladen können. Dadurch erhalten Sie das weiterverteilbare Dateiarchiv mit dem aktuellen Namen Microsoft.WindowsAppRuntime.Redist.1.0.0.zip, das Installationsprogramme für x86- und x64-Plattformen (beide WindowsAppRuntimeInstaller.exe genannt) in sinnvoll benannten Ordnern enthält.
Durch Ausführen des Installationsprogramms (mit erhöhten Rechten) wird sichergestellt, dass Sie die Windows App Runtime installiert haben – sie wird in versteckte Ordner unter C:Program FilesWindowsApps verschoben, die x86-Version kann beispielsweise in C:Program FilesWindowsAppsMicrosoft.WindowsAppRuntime.1.0_0.319.455 installiert werden .0_x86__8wekyb3d8bbwe.
2. Das zweite, was Sie brauchen, ist die Windows App Runtime Loader DLL , Microsoft.WindowsAppRuntime.Bootstrap.dll. Diese Datei wird aus dem Windows App SDK NuGet-Paket, derzeit Microsoft.WindowsAppSDK.1.0.0.nupkg, abgerufen, das unter https://www.nuget.org/packages/Microsoft.WindowsAppSDK im Ordner runtimeswin10-x86native oder verfügbar ist Laufzeitenwin10-x64nativ. Diese DLL sollte neben Ihrer ausführbaren Datei platziert werden, damit sie beim Start der Anwendung gefunden wird, wenn die relevanten APIs aufgerufen werden. Die Loader-DLL (oder Bootstrap-DLL) ist dafür verantwortlich, eine geeignete Version der Windows App Runtime zu finden, die WinUI 3 implementiert, basierend auf den Versionswerten, die an ihre Start-API übergeben werden.
Hinweis: Wenn Sie die TEdgeBrower-Komponentenunterstützung von Delphi verwendet haben, die eine weitere Funktion des Windows App SDK umschließt, stellen Sie möglicherweise eine Ähnlichkeit in den Anforderungen für eine Laufzeit (ebenfalls von Endbenutzern benötigt) und ein SDK mit einer verteilbaren geladenen DLL fest
Herunterladen der Demo
Die Delphi WinUI 3-Demo ist auf GetIt für Kunden von RAD Studio 11 Alexandria verfügbar. Durch die Installation wird der Quellcode der Demo und der erforderlichen Bibliotheksdateien zusammen mit einer Readme-Datei mit ähnlichem Inhalt wie dieser Blog-Beitrag installiert. Dies ist das GetIt-Paket:
Einführung in die Demo
Die Demo-Anwendung ist als Konsolen-App erstellt, nicht aus Notwendigkeit, aber so können Informationen in das Konsolenfenster geschrieben werden, während die Anwendung fortschreitet, und bietet auch eine Möglichkeit, Fehlermeldungen anzuzeigen (z. B. fehlende Abhängigkeiten).
Hinweis: WinUI 3 erfordert, dass Sie den Prozess ohne erhöhte Rechte ausführen. Daher überprüft die Demo dies und wird mit einer einfachen Nachricht beendet, wenn sie erhöhte Berechtigungen findet. Ohne diese Überprüfung stürzt WinUI 3 die Anwendung auf scheinbar gnadenlose Weise ab.
Unter der Annahme, dass wir die Berechtigungsprüfung bestehen, ruft die App die Initialisierungs-API in der Loader-DLL MddBootstrapInitialize auf , und wenn diese die Windows App Runtime findet und startet, fährt die Anwendung mit der weiteren Initialisierung fort. Vor dem Beenden der App ruft MddBootstrapShutdown zum Aufräumen auf:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
uses WinRT; const // From includeWindowsAppSDK-VersionInfo.h in WinAppSDK NuGet package WINDOWSAPPSDK_RELEASE_MAJORMINOR = $00010000; WINDOWSAPPSDK_RUNTIME_VERSION_UINT64 = $0000013F01C70000; WINDOWSAPPSDK_RUNTIME_VERSION_DOTQUADSTRING = '0.319.455.0'; var PackageVersion: PACKAGE_VERSION; ... PackageVersion.Version := WINDOWSAPPSDK_RUNTIME_VERSION_UINT64; var HR := MddBootstrapInitialize(WINDOWSAPPSDK_RELEASE_MAJORMINOR, nil, PackageVersion); if Succeeded(HR) <strong>then try Main; WriteLn('Press Enter (again) to continue'); Readln; finally MddBootstrapShutdown; |
Wie Sie sehen können, werden die SDK-Release- und Runtime-Paketversionen aus einer Header-Datei (.h) ausgeliehen, die sich im Windows App SDK NuGet-Paket befindet.
Innerhalb von Main rufen wir die statische Start – Methode des WinUI 3-Application-Objekts auf – siehe https:// docs.microsoft.com/en-us/windows/winui/api/microsoft.ui.xaml.application.start . Dies erfordert einen Rückruf, der ausgeführt wird, wenn die Anwendung initialisiert wird, sodass wir die Dinge nach Belieben einrichten können. Glücklicherweise haben WinRT-Callbacks (einschließlich WinUI 3-Callbacks) dieselbe Implementierung wie eine anonyme Delphi-Methode, sodass wir eine anonyme Methode verwenden, um den OnLaunched – Ereignishandler unserer Anwendung einzurichten.
In WinUI 3 ist OnLaunched eigentlich kein Eventhandler. Stattdessen ist OnLaunched – https://docs.microsoft.com/en-us/windows/winui/api/microsoft.ui.xaml.application.onlaunched – eine Methode, die wir in einer Klasse überschreiben sollen, die von der WinUI erbt Anwendungsklasse. Wie gehen wir mit dieser Anforderung um, von einer WinRT-Klasse von Delphi zu erben?
WinUI hilft uns dabei, indem es einen Mechanismus bereitstellt, den wir nutzen können. In einem solchen Fall umfasst das Erben von einer WinUI 3-Klasse 3 Objekte:
1) Ein inneres Objekt, das die von WinUI bereitgestellte Basisimplementierung angibt, in diesem Fall eine Basisanwendungsimplementierung. Dieses innere Objekt implementiert eine Schnittstelle, die die Methode(n) definiert, für die wir Implementierungen bereitstellen werden; IApplicationOverrides in diesem Fall.
2) Ein äußeres Objekt (manchmal als Basisobjekt bezeichnet), das die benutzerdefinierte Implementierung der betreffenden Methode(n) bereitstellt. Dieses äußere Objekt, das wir bereitstellen werden, implementiert auch IApplicationOverrides .
3) Ein Wrapper-Objekt, das das innere und das äußere Objekt kombiniert und von WinUI bereitgestellt wird
Hier ist der Code von Main :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
var AppInner: IInspectable; var AppOuter: IApplicationOverrides; var AppWrapper: IApplication; // In this code block we use an anonymous procedure (which Delphi implements as an // interface with an Invoke method) that matches the layout of the callback interface type TCallbackProc = reference to procedure (p: IApplicationInitializationCallbackParams) safecall; procedure Main; begin // Here we define an anonymous method and cast it to the matching WinUI interface type var CallbackProc: TCallbackProc := procedure (p: IApplicationInitializationCallbackParams) safecall begin // First we create our derived class AppOuter := TDerivedApp.Create as IApplicationOverrides; // Then we get the IApplicationFactory... var Factory := TApplication.Factory; // ... and use it to get an IApplication wrapper, AppWrapper, // and an IApplicationOverrides inner as well AppWrapper := Factory.CreateInstance(AppOuter, AppInner); // We store the inner object in the outer one so // we can call the base functionality when needed AppOuter.Inner := AppInner as IApplicationOverrides; end; var AppInitCallback := ApplicationInitializationCallback(CallbackProc); TApplication.Start(AppInitCallback); end; |
Der Anwendungsanpassungscode stammt aus dieser Klasse:
|
1 2 3 4 5 6 7 8 9 10 |
type TDerivedApp = class(TInspectableObject, IApplicationOverrides) private FInner: IApplicationOverrides; public // IApplicationOverrides methods procedure OnLaunched(args: ILaunchActivatedEventArgs); safecall; ... property Inner: IApplicationOverrides read FInner write FInner; end; |
Die OnLaunched- Methode kann dann die gesamte erforderliche App-Einrichtung durchführen. In diesem Fall erstellen und richten wir ein Fenster ein – https://docs.microsoft.com/en-us/windows/winui/api/microsoft.ui.xaml.window und füllen es mit einigen Steuerelementen, wodurch die folgende Benutzeroberfläche erstellt wird:
Sehen Sie sich den Code an, um alle Details darüber zu erfahren, was vor sich geht, aber zusammengefasst:
- Wir erstellen ein StackPanel -Steuerelement und platzieren es im Fenster, dann wird eine Schaltfläche mit einem Click-Ereignishandler erstellt und dem StackPanel hinzugefügt .
- Als Nächstes verwenden wir etwas XAML, um ein weiteres StackPanel und ein untergeordnetes Schaltflächensteuerelement zu erstellen, wiederum mit einem Click-Ereignishandler, der das StackPanel zum Fenster hinzufügt. Das gibt uns 2 Ansätze, um das gleiche Ziel zu erreichen.
- Schließlich wird etwas mehr XAML verwendet, um ein Grid und darin einen TextBlock zu erstellen , dem dann ein paar Event-Handler für OnPointerEntered und OnPointerExited hinzugefügt wurden .
- Am Ende haben wir ein Fenster mit ein paar Schaltflächen und einem Textblock. Die Schaltflächen können angeklickt werden, um ihre Beschriftung zu ändern, und der Textblock ändert seine Farbe, wenn Sie die Maus hinein- und herausbewegen.
Beachten Sie, dass für dynamisch erstellte UI-Steuerelemente (wie die erste Schaltfläche) die Ereignishandler direkt zugeordnet werden können, während beim Erstellen der Steuerelemente beim Laden einer XAML-Konfiguration der Code das übereinstimmende Objekt suchen muss, um ihm einen Ereignishandler zuzuordnen.
Hinweis: Im Gegensatz zu C# und C++ integriert die Sprachprojektion für Delphi derzeit nicht alle verschiedenen Schnittstellen, die von WinRT- und WinUI 3-Objekten in einheitliche Proxy-Klassen implementiert werden, und daher wird viel mehr Schnittstellenarbeit geleistet, als dies anderswo der Fall wäre.
Was kommt als nächstes
Diese Demo der Verwendung von Win UI 3 in einer paketierten oder nicht paketierten Delphi 11-Anwendung ist in erster Linie für alle gedacht, die mit dieser neuen UI-Technologie aus Delphi-Sicht experimentieren möchten. Als Embarcadero verfolgen wir die Entwicklung von WinUI 3 und planen, wie wir es in Zukunft unterstützen können. Microsoft hat die zukünftige Unterstützung für das Hosten von WinUI 3-Steuerelementen innerhalb eines herkömmlichen Windows-Formularhandles (d. h. einer VCL- oder FMX-App) über XAML Islands für Win UI 3 angekündigt – eine Funktion, die für Ende 2022 erwartet wird, daher ist es für uns noch recht früh, darüber zu diskutieren ein Plan für eine reibungslosere Integration. Bleib dran.
Design. Code. Compile. Deploy.
Start Free Trial Upgrade Today
Free Delphi Community Edition Free C++Builder Community Edition
