Ontem, no 27º aniversário da Delphi, a Embarcadero lançou uma demonstração do WinUI 3 que apresentei no webinar de aniversário. Aqui está o anúncio oficial, juntamente com algumas informações mais técnicas. A demonstração está disponível no GetIt.
Table of Contents
Introdução
O Windows App SDK da Microsoft (anteriormente conhecido como Project Reunion) inclui uma nova estrutura de interface do usuário nativa chamada WinUI 3. WinUI 3 é a estrutura de interface do usuário atual na arquitetura WinRT (Windows Runtime) e está disponível para aplicativos empacotados (via contêineres APPX ou MSIX) e aplicativos GUI não empacotados (que são aplicativos nativos Win32/Win64 comuns, como aqueles criados com Delphi e RAD Studio. Essa referência a aplicativos empacotados não tem nada a ver com pacotes Delphi.
Lembre-se também de que o Windows App SDK é um conjunto diferente de ferramentas do Windows SDK de nome semelhante, disponível como parte da instalação do Delphi por um longo tempo.
O projeto de amostra SampleWinRT destina-se a mostrar como construir um aplicativo Delphi GUI simples puramente a partir da estrutura WinUI 3 (1.0) da Microsoft, lançada em novembro de 2021. As versões de pré-lançamento do WinUI3 exigiam que o aplicativo fosse implantado como um aplicativo empacotado do Windows, mas o WinUI 3 (1.0) remove essa restrição, o que significa que você pode criar um aplicativo WinUI 3 no Delphi como um aplicativo normal.
Você pode encontrar mais sobre o WinUI 3 aqui: https://docs.microsoft.com/en-us/windows/apps/winui/winui3
Você pode encontrar mais sobre o Windows App SDK aqui: https://docs.microsoft.com /pt-br/windows/apps/windows-app-sdk/
A demonstração vem com versões atualizadas das unidades de importação WinRT Delphi RTL, para suportar a versão 1.0 do WinUI 3. A versão atual do Delphi 11 Alexandria vem com um conjunto mais antigo das mesmas unidades de importação.
Pré-requisitos: instalador do Windows App Runtime e DLL do Windows App Runtime Loader
Para criar e implantar um aplicativo não empacotado, você precisa de algumas coisas, conforme detalhado em https://docs.microsoft.com/en-us/windows/apps/windows-app-sdk/deploy-unpackaged-apps
1. Primeiro, você precisa do instalador do Windows App SDK , que pode ser obtido em um link de download na página da Microsoft mencionada acima ou em https://aka.ms/windowsappsdk/1.0-stable/msix-installer. Isso fornece o arquivo de arquivo redistribuível, atualmente chamado de Microsoft.WindowsAppRuntime.Redist.1.0.0.zip, que contém instaladores para plataformas x86 e x64 (ambas chamadas WindowsAppRuntimeInstaller.exe) em pastas com nomes sensatos.
A execução do instalador (com privilégios elevados) garantirá que você tenha o Windows App Runtime instalado – ele vai para pastas ocultas em C:Program FilesWindowsApps, por exemplo, a versão x86 pode ser instalada em C:Program FilesWindowsAppsMicrosoft.WindowsAppRuntime.1.0_0.319.455 .0_x86__8wekyb3d8bbwe.
2. A segunda coisa que você precisa é a DLL do carregador do Windows App Runtime , Microsoft.WindowsAppRuntime.Bootstrap.dll. Esse arquivo é obtido no pacote NuGet do Windows App SDK, atualmente Microsoft.WindowsAppSDK.1.0.0.nupkg, que está disponível em https://www.nuget.org/packages/Microsoft.WindowsAppSDK na pasta runtimeswin10-x86native ou runtimeswin10-x64native. Essa DLL deve ser colocada ao lado de seu executável para ser localizada na inicialização do aplicativo quando as APIs relevantes forem chamadas. A DLL do carregador (ou DLL de bootstrap) é responsável por localizar uma versão adequada do Windows App Runtime, que implementa o WinUI 3, com base nos valores de versão passados para sua API de inicialização.
Nota: Se você usou o suporte ao componente TEdgeBrower do Delphi, que envolve outro recurso do Windows App SDK, você pode notar uma semelhança nos requisitos para um tempo de execução (também necessário para usuários finais) e um SDK com uma DLL carregada redistribuível
Baixando a demonstração
A demonstração do Delphi WinUI 3 está disponível no GetIt para clientes do RAD Studio 11 Alexandria. Ao instalá-lo, o código-fonte da demonstração e dos arquivos de biblioteca necessários é instalado junto com um arquivo leia-me com conteúdo semelhante a esta postagem no blog. Este é o pacote GetIt:
Apresentando a demonstração
O aplicativo de demonstração é construído como um aplicativo de console, não por necessidade, mas para que as informações possam ser gravadas na janela do console à medida que o aplicativo avança, oferecendo também uma maneira de exibir mensagens de erro (como dependências ausentes)
Nota: WinUI 3 requer que você execute o processo sem privilégios elevados. Como tal, a demonstração verifica isso e sai com uma mensagem simples se encontrar privilégios elevados. Sem essa verificação, o WinUI 3 trava o aplicativo de maneira aparentemente sem graça.
Supondo que passamos na verificação de privilégios, o aplicativo chama a API de inicialização na DLL do carregador, MddBootstrapInitialize e, se isso localizar e iniciar o Windows App Runtime, o aplicativo continuará com a inicialização. Antes de sair do aplicativo, chama MddBootstrapShutdown para limpar:
|
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; |
Como você pode ver, as versões de lançamento do SDK e do pacote de tempo de execução são emprestadas de um arquivo de cabeçalho (.h) localizado no pacote NuGet do Windows App SDK
Dentro do Main , chamamos o método Start estático do objeto WinUI 3 Application – consulte https:// docs.microsoft.com/en-us/windows/winui/api/microsoft.ui.xaml.application.start . Isso leva um retorno de chamada que será executado quando o aplicativo for inicializado, permitindo que configuremos as coisas como desejamos. Fortuitamente, os retornos de chamada do WinRT (incluindo os retornos de chamada do WinUI 3) têm a mesma implementação que um método anônimo do Delphi, portanto, usamos um método anônimo para configurar o manipulador de eventos OnLaunched do nosso aplicativo.
No WinUI 3 OnLaunched não é realmente um manipulador de eventos. Em vez disso , OnLaunched – https://docs.microsoft.com/en-us/windows/winui/api/microsoft.ui.xaml.application.onlaunched – é um método que devemos substituir em uma classe que herda do WinUI Classe de aplicação. Como lidamos com esse requisito de herdar de uma classe WinRT do Delphi?
WinUI nos ajuda fornecendo um mecanismo que podemos usar. Em um caso como este, herdar de uma classe WinUI 3 envolve 3 objetos:
1) Um objeto interno que fornece a implementação base, que é fornecida pelo WinUI, neste caso uma implementação base do aplicativo. Este objeto interno implementará uma interface que define os métodos para os quais forneceremos implementações; IApplicationSubstitui neste caso.
2) Um objeto externo (às vezes chamado de objeto base) que fornece a implementação personalizada do(s) método(s) em questão. Esse objeto externo, que forneceremos, também implementará IApplicationOverrides .
3) Um objeto wrapper, que combina o objeto interno e externo, e é fornecido pelo WinUI
Aqui está o código de 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; |
O código de personalização do aplicativo é desta classe:
|
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; |
O método OnLaunched fica então livre para fazer toda a configuração do aplicativo necessária. Nesse caso, criamos e configuramos uma Janela – https://docs.microsoft.com/en-us/windows/winui/api/microsoft.ui.xaml.window e a preenchemos com alguns controles, criando a seguinte UI:
Procure no código todos os detalhes do que está acontecendo, mas em resumo:
- Criamos um controle StackPanel e o colocamos na janela, então um botão é criado com um manipulador de eventos Click e adicionado ao StackPanel .
- Em seguida, usamos algum XAML para criar outro StackPanel e um controle filho de botão, novamente com um manipulador de eventos Click, adicionando o StackPanel à janela. Isso nos dá 2 abordagens para atingir o mesmo objetivo.
- Finalmente, um pouco mais de XAML é usado para criar um Grid e dentro dele um TextBlock , que então tem alguns manipuladores de eventos adicionados para OnPointerEntered e OnPointerExited .
- Por fim, acabamos com uma janela mostrando alguns botões e um bloco de texto. Os botões podem ser clicados para alterar sua legenda e o bloco de texto muda de cor quando você move o mouse para dentro e para fora dele.
Observe que para controles de interface do usuário criados dinamicamente (como o primeiro botão), os manipuladores de eventos podem ser associados diretamente, enquanto quando os controles são criados carregando uma configuração XAML, o código precisa localizar o objeto correspondente para associar um manipulador de eventos a ele.
Nota: diferentemente de C# e C++, a projeção de linguagem para Delphi atualmente não incorpora todas as várias interfaces implementadas por objetos WinRT e WinUI 3 em classes de proxy unificadas e, portanto, há muito mais trabalho de interface em andamento do que seria o caso em outros lugares.
Qual é o próximo
Esta demonstração do uso do Win UI 3 em um aplicativo Delphi 11 empacotado ou não empacotado destina-se principalmente a qualquer pessoa que queira experimentar essa nova tecnologia de interface do usuário do ponto de vista do Delphi. Como Embarcadero, estamos acompanhando a evolução do WinUI 3 e planejando como apoiá-lo no futuro. A Microsoft anunciou suporte futuro para hospedar controles WinUI 3 em um identificador de formulário tradicional do Windows (ou seja, um aplicativo VCL ou FMX) por meio de ilhas XAML para Win UI 3 — um recurso esperado para o final de 2022, portanto, é muito cedo para discutirmos um plano para uma integração mais suave. Fique ligado.
Design. Code. Compile. Deploy.
Start Free Trial Upgrade Today
Free Delphi Community Edition Free C++Builder Community Edition
