Partilhar via

Mostrar objetos da interface WinRT que dependem do CoreWindow

Certos seletores, popups, diálogos e outros objetos do Windows Runtime (WinRT) dependem de um CoreWindow; tipicamente para mostrar uma interface de utilizador (UI). Embora o CoreWindow não seja suportado em aplicações de ambiente de trabalho (ver Classes Core não suportadas), ainda pode usar muitas dessas classes WinRT na sua aplicação de desktop adicionando um pouco de código de interoperabilidade.

A sua aplicação de ambiente de trabalho pode ser WinUI 3, Windows Presentation Foundation (WPF) ou Windows Forms (WinForms ). Exemplos de código são apresentados em C# e C++/WinRT.

Defina o handle de janela do proprietário (HWND) para um objeto de UI do WinRT

Para classes que implementam a interface IInitializeWithWindow (ou a interface equivalente IDataTransferManagerInterop ), pode usar essa interface para definir uma janela proprietária no objeto antes de o exibir. É um processo em dois passos.

  1. Decide qual janela será a proprietária do objeto UI que queres mostrar e recupera o HWND dessa janela. Para mais detalhes e exemplos de código para esta etapa, consulte Obter um identificador de janela (HWND).
  2. Depois, chame a API de interoperabilidade apropriada (para C# ou C++/WinRT) para definir um handle de janela proprietária (HWND) para o objeto UI do WinRT.

Para classes que implementam IInitializeWithWindow

Estas classes implementam o IInitializeWithWindow:

Observação

A lista acima é necessariamente incompleta — consulte a documentação de um tipo para ver se implementa o IInitializeWithWindow (ou uma interface de interoperabilidade equivalente).

As secções seguintes contêm exemplos de código para mostrar um FolderPicker. Mas é a mesma técnica para mostrar qualquer uma das APIs mencionadas acima.

WinUI 3 com C# (também WPF/WinForms com .NET 6 ou posterior)

Observação

Os exemplos de código nesta secção utilizam a classe de interoperabilidade WinRT.Interop.WindowNative C#. Se escolheres .NET 6 ou versões posteriores, podes usar essa classe num projeto WPF ou WinForms. Para informações sobre como configurar o seu projeto para isso, veja APIs de interoperabilidade de chamadas a partir de uma aplicação .NET.

O código C# abaixo espera que já tenha usado o padrão documentado em Retrieve a window handle (HWND). Depois, para definir a janela proprietária do objeto UI que pretende mostrar, o código chama o método Initialize na classe de interop WinRT.Interop.InitializeWithWindow C#. Para mais informações sobre as classes de interoperabilidade em C#, veja APIs de interoperação de chamadas a partir de uma aplicação .NET.

// MainWindow.xaml.cs
private async void ShowFolderPickerAsync(IntPtr hWnd)
{
    // Create a folder picker.
    var folderPicker = new Windows.Storage.Pickers.FolderPicker();

    // Initialize the folder picker with the window handle (HWND).
    WinRT.Interop.InitializeWithWindow.Initialize(folderPicker, hWnd);

    // Use the folder picker as usual.
    folderPicker.FileTypeFilter.Add("*");
    var folder = await folderPicker.PickSingleFolderAsync();
}

WinUI 3 com C++

O código C++/WinRT abaixo espera que já tenha usado o padrão documentado em Retrieve a window handle (HWND). Depois, para definir a janela proprietária do objeto UI que pretende mostrar, o código chama o método de interoperabilidade IInitializeWithWindow::Initialize.

// pch.h
...
#include <microsoft.ui.xaml.window.h>
#include <Shobjidl.h>
#include <winrt/Windows.Storage.Pickers.h>

// MainWindow.xaml.cpp
winrt::fire_and_forget ShowFolderPickerAsync(HWND hWnd)
{
    // Create a folder picker.
    Windows::Storage::Pickers::FolderPicker folderPicker;

    // Initialize the folder picker with the window handle (HWND).
    auto initializeWithWindow{ folderPicker.as<::IInitializeWithWindow>() };
    initializeWithWindow->Initialize(hWnd);

    // Use the folder picker as usual.
    folderPicker.FileTypeFilter().Append(L"*");
    auto folder{ co_await folderPicker.PickSingleFolderAsync() };
}

Para classes que implementam IDataTransferManagerInterop

A classe Windows.ApplicationModel.DataTransfer.DataTransferManager implementa a interface IDataTransferManagerInterop (que, tal como o IInitializeWithWindow, permite definir uma janela de proprietário).

Numa aplicação de ambiente de trabalho, em vez de chamar o método DataTransferManager.ShowShareUI , chama IDataTransferManagerInterop::ShowShareUIForWindow, como mostrado nos exemplos de código abaixo.

WinUI 3 com C# (também WPF/WinForms com .NET 6 ou posterior)

// MainWindow.xaml.cs
...
public sealed partial class MainWindow : Window
{
    ...

    [System.Runtime.InteropServices.ComImport]
    [System.Runtime.InteropServices.Guid("3A3DCD6C-3EAB-43DC-BCDE-45671CE800C8")]
    [System.Runtime.InteropServices.InterfaceType(
        System.Runtime.InteropServices.ComInterfaceType.InterfaceIsIUnknown)]
    interface IDataTransferManagerInterop
    {
        IntPtr GetForWindow([System.Runtime.InteropServices.In] IntPtr appWindow,
            [System.Runtime.InteropServices.In] ref Guid riid);
        void ShowShareUIForWindow(IntPtr appWindow);
    }

    static readonly Guid _dtm_iid = 
        new Guid(0xa5caee9b, 0x8708, 0x49d1, 0x8d, 0x36, 0x67, 0xd2, 0x5a, 0x8d, 0xa0, 0x0c);

    private void myButton_Click(object sender, RoutedEventArgs e)
    {
        // Retrieve the window handle (HWND) of the current WinUI 3 window.
        var hWnd = WinRT.Interop.WindowNative.GetWindowHandle(this);

        IDataTransferManagerInterop interop =
        Windows.ApplicationModel.DataTransfer.DataTransferManager.As
            <IDataTransferManagerInterop>();

        IntPtr result = interop.GetForWindow(hWnd, _dtm_iid);
        var dataTransferManager = WinRT.MarshalInterface
            <Windows.ApplicationModel.DataTransfer.DataTransferManager>.FromAbi(result);

        dataTransferManager.DataRequested += (sender, args) =>
        {
            args.Request.Data.Properties.Title = "In a desktop app...";
            args.Request.Data.SetText("...display WinRT UI objects that depend on CoreWindow.");
            args.Request.Data.RequestedOperation = 
                Windows.ApplicationModel.DataTransfer.DataPackageOperation.Copy;
        };

        // Show the Share UI
        interop.ShowShareUIForWindow(hWnd);
    }
}
...

WinUI 3 com C++

// pch.h in a Windows App SDK app
...
#include <shobjidl_core.h>
#include <microsoft.ui.xaml.window.h>
#include <winrt/Windows.ApplicationModel.DataTransfer.h>
...

// MainWindow.xaml.cpp
...
void MainWindow::myButton_Click(IInspectable const&, RoutedEventArgs const&)
{
    // Retrieve the window handle (HWND) of the current WinUI 3 window.
    auto windowNative{ this->m_inner.as<::IWindowNative>() };
    HWND hWnd{ 0 };
    windowNative->get_WindowHandle(&hWnd);

    winrt::com_ptr<IDataTransferManagerInterop> interop = 
        winrt::get_activation_factory<Windows::ApplicationModel::DataTransfer::DataTransferManager,
        IDataTransferManagerInterop>();

    winrt::guid _dtm_iid{ 0xa5caee9b, 0x8708, 0x49d1, { 0x8d, 0x36, 0x67, 0xd2, 0x5a, 0x8d, 0xa0, 0x0c } };
    Windows::ApplicationModel::DataTransfer::DataTransferManager dataTransferManager{ nullptr };
    interop->GetForWindow(hWnd, _dtm_iid, winrt::put_abi(dataTransferManager));

    dataTransferManager.DataRequested([](Windows::ApplicationModel::DataTransfer::DataTransferManager const& /* sender */,
        Windows::ApplicationModel::DataTransfer::DataRequestedEventArgs const& args)
    {
        args.Request().Data().Properties().Title(L"In a desktop app...");
        args.Request().Data().SetText(L"...display WinRT UI objects that depend on CoreWindow.");
        args.Request().Data().RequestedOperation(Windows::ApplicationModel::DataTransfer::DataPackageOperation::Copy);
    });

    interop->ShowShareUIForWindow(hWnd);
}
...

Para classes que implementam IUserConsentVerifierInterop

A classe Windows.Security.Credentials.UI.UserConsentVerifier implementa a interface IUserConsentVerifierInterop (que, tal como o IInitializeWithWindow, permite definir uma janela de proprietário).

Numa aplicação de ambiente de trabalho, em vez de chamar o método UserConsentVerifier.RequestVerificationAsync :

Para mais informações e exemplos de código, consulte UserConsentVerifier.

Para classes que implementam outras interfaces de interoperabilidade

Estas interfaces têm métodos XxxForWindow , que permitem definir um handle de janela proprietário (HWND). Pode usar estas interfaces diretamente a partir do C++/WinRT. Versões das interfaces também existem sob a forma de classes C# — para mais detalhes, veja APIs de interoperação de chamadas a partir de uma aplicação .NET.

  • Last updated on