Partilhar via

Aplicar o Mica em aplicações de ambiente de trabalho Win32 para Windows 11

Mica é um material opaco que incorpora o tema do usuário e o papel de parede da área de trabalho para criar uma aparência altamente personalizada. À medida que o usuário move a janela pela tela, o material Mica se adapta dinamicamente para criar uma visualização rica usando o papel de parede abaixo do aplicativo. Além disso, o material ajuda os usuários a se concentrarem na tarefa atual, caindo de volta para uma cor neutra quando o aplicativo está inativo.

Este artigo descreve como aplicar o Mica como a camada base do seu aplicativo Win32, priorizando o aplicativo e a visibilidade na área da barra de título. Para obter mais informações sobre camadas de aplicativos com o Mica, consulte material do Mica.

Pré-requisitos

Para aplicar o Mica a uma aplicação Win32 para Windows 11, é necessário usar o SDK do Aplicativo Windows. Você precisará do seguinte:

Como usar o Mica em aplicativos Win32

Para usar mica na sua aplicação, utilize a classe MicaController. Esta classe gerencia a renderização do material de pano de fundo do sistema, bem como a manipulação da política do sistema para o material mica.

O MicaController reage aos temas Luz e Escuridão do sistema por padrão. Para substituir esse comportamento, você pode passar as seguintes propriedades para o MicaController:

Sugestão

O código nesta seção é retirado do exemplo Win32 Mica do Windows App SDK no GitHub. Consulte o repositório GitHub para obter o código completo. Estes exemplos usam C++/WinRT.

Para habilitar o Mica, você precisa de uma referência ao SDK do Aplicativo Windows, umCompositor e umDispatcherQueue .

Este exemplo mostra como fazer o seguinte para configurar um aplicativo não empacotado:

A partir de WinMain.cpp

int __stdcall WinMain(_In_ HINSTANCE, _In_opt_ HINSTANCE,  _In_ PSTR, _In_ int)
{
    // Initialize WinRt Instance
    winrt::init_apartment();

    // Enable referencing the WindowsAppSDK from an unpackaged app.
    Utilities::WindowsAppSDKBootstrapperContext sdkContext;

    // Register Window class before making the window.
    MicaWindow::RegisterWindowClass();

    // Mica requires a compositor, which also requires a dispatcher queue.
    auto controller = Utilities::CreateDispatcherQueueControllerForCurrentThread();
    auto compositor = winrt::Compositor();

    // Create your window...
    ...
}

A partir de MicaWindow.cpp

void MicaWindow::RegisterWindowClass()
{
    auto instance = winrt::check_pointer(GetModuleHandleW(nullptr));
    WNDCLASSEX wcex = { sizeof(wcex) };
    wcex.style = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc = WndProc;
    wcex.hInstance = instance;
    wcex.hIcon = LoadIconW(instance, IDI_APPLICATION);
    wcex.hCursor = LoadCursorW(nullptr, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszClassName = ClassName.c_str();
    wcex.hIconSm = LoadIconW(wcex.hInstance, IDI_APPLICATION);
    winrt::check_bool(RegisterClassExW(&wcex)); // check if the window class was registered successfully
}

O método winrt::init_apartment é multi-threaded por padrão. Se o seu aplicativo exigir um único thread, como o exemplo WebView2 , poderá definir facilmente o tipo.

winrt::init_apartment(winrt::apartment_type::single_threaded);

Agora você pode usar a CreateWindowEx() função para criar uma janela. Em seguida, temos que criar um alvo de janela e defini-lo como a raiz para especificar a qual camada aplicar o Mica. Finalmente, afirme que Mica é suportado pela janela e pelo alvo.

O exemplo Win32 Mica cria as classes DesktopWindow e MicaWindow para fazer esse trabalho. Estas classes definem: ClassName, windowTitle, m_target, m_micaController, e m_isMicaSupported.

A partir de WinMain.cpp

// Mica window is inherited from the MicaWindow class, which is an extension of the DesktopWindow Class.
// Here, we initialize the main window and set the title.
   auto window = MicaWindow(compositor, L"Hello, Mica!");

A partir de MicaWindow.cpp

// Create the main window and enable Mica.
MicaWindow::MicaWindow(const winrt::Compositor& compositor, const std::wstring& windowTitle)
{
    auto instance = winrt::check_pointer(GetModuleHandleW(nullptr));
    WINRT_ASSERT(!m_window); // check that window is not initialized
    WINRT_VERIFY(
        // Window Properties
        CreateWindowExW(
            WS_EX_COMPOSITED,
            ClassName.c_str(), // declared in MicaWindow.h and defined above
            windowTitle.c_str(),
            WS_OVERLAPPEDWINDOW,
            CW_USEDEFAULT,
            CW_USEDEFAULT, 
            800, 600, 
            nullptr, 
            nullptr, 
            instance, 
            this
        ));

    // Check that the window was created successfully.
    WINRT_ASSERT(m_window);

    ShowWindow(m_window, SW_SHOWDEFAULT);
    UpdateWindow(m_window);

    // The Mica controller needs to set a target with a root to recognize the visual base layer.
    m_target = CreateWindowTarget(compositor);

    // Need to set a root before we can enable Mica.
    m_target.Root(compositor.CreateContainerVisual());

    m_micaController = winrt::MicaController();
    m_isMicaSupported = m_micaController.SetTarget(winrt::Microsoft::UI::WindowId{ reinterpret_cast<uint64_t>(m_window) }, m_target);
}

Como usar o Mica em aplicativos Win32 WebView2

Os princípios fundamentais da aplicação do Mica são consistentes na maioria dos aplicativos Win32. O processo para WebView2 segue as etapas básicas das instruções do Win32 mostradas anteriormente. No entanto, neste caso, você precisará especificar um único processo encadeado do recurso do init_apartment WinRT.

Sugestão

O código nesta seção é retirado do exemplo de Mica WebView2 do SDK de Aplicativo Windows no GitHub. Consulte o repositório GitHub para obter o código completo.

Para começar, configure o apartamento, controlador, compositor, destino e raiz necessários. Por padrão, a função init_apartment do WinRT é multithreaded, mas o WebView2 é inerentemente monothread. Para definir init_apartment como um único thread, passe o winrt::apartment_type::single_threaded parâmetro. No exemplo Mica WebView2, simplificamos a sintaxe criando uma classe separada para funções de exibição da Web, referenciada no código a seguir.

A partir de Main.cpp

int __stdcall WinMain(_In_ HINSTANCE, _In_opt_ HINSTANCE, _In_ PSTR, _In_ int)
{
    winrt::init_apartment(winrt::apartment_type::single_threaded);
    // Enable referencing the WindowsAppSDK from an unpackaged app.
    // Remember to have a matching Microsoft.WindowsAppRuntime.Redist installed.
    // https://learn.microsoft.com/windows/apps/windows-app-sdk/deploy-unpackaged-apps
    Utilities::WindowsAppSDKBootstrapperContext sdkContext;
    CompositionWindow::RegisterWindowClass();
    // A dispatcher queue is required to be able to create a compositor.
    auto controller = Utilities::CreateDispatcherQueueControllerForCurrentThread();
    auto compositor = winrt::Compositor();
    auto window = WebView2Window(compositor, L"Hello, WebView2!");

    ...
}

Para obter uma demonstração completa da classe WebView2Window e a sua integração com o Mica, consulte o exemplo de Windows App SDK WebView2 Mica no GitHub. Observe como as classes CompositionWindow e WebView2Window manipulam mensagens, inicializam o ambiente de exibição da Web e excluem o controlador de janela quando a janela é fechada.

Materiais, Camadas e Elevação, Exemplos de Mica do Windows App SDK

  • Last updated on