Partilhar via

Mostrar várias vistas com ApplicationView

Ajude seus usuários a serem mais produtivos, permitindo que eles visualizem partes independentes do seu aplicativo em janelas separadas. Quando você cria várias janelas para um aplicativo, cada janela se comporta de forma independente. A barra de tarefas mostra cada janela separadamente. Os utilizadores podem mover, redimensionar, mostrar e ocultar janelas de aplicações de forma independente e podem alternar entre janelas de aplicações como se fossem aplicações separadas. Cada janela opera em seu próprio thread.

APIs importantes: ApplicationViewSwitcher, CreateNewView

O que é uma vista?

Uma vista de aplicação é o emparelhamento 1:1 de um segmento e uma janela que a aplicação usa para mostrar conteúdo. Ele é representado por um objeto Windows.ApplicationModel.Core.CoreApplicationView .

As exibições são gerenciadas pelo objeto CoreApplication . Você chama CoreApplication.CreateNewView para criar um objeto CoreApplicationView . O CoreApplicationView reúne uma CoreWindow e um CoreDispatcher (armazenados nas propriedades CoreWindow e Dispatcher). Você pode pensar no CoreApplicationView como o objeto que o Tempo de Execução do Windows usa para interagir com o sistema principal do Windows.

Normalmente, você não trabalha diretamente com o CoreApplicationView. Em vez disso, o Tempo de Execução do Windows fornece a classe ApplicationView no namespace Windows.UI.ViewManagement. Essa classe fornece propriedades, métodos e eventos que você usa quando seu aplicativo interage com o sistema de janelas. Para trabalhar com um ApplicationView, chame o método estático ApplicationView.GetForCurrentView, que obtém uma instância de ApplicationView vinculada ao fio de execução atual do CoreApplicationView.

Da mesma forma, a estrutura XAML encapsula o objeto CoreWindow em um objeto Windows.UI.XAML.Window. Em um aplicativo XAML, você normalmente interage com o objeto Window em vez de trabalhar diretamente com a CoreWindow.

Mostrar uma nova vista

Embora cada layout de aplicativo seja exclusivo, recomendamos incluir um botão "nova janela" em um local previsível, como o canto superior direito do conteúdo que pode ser aberto em uma nova janela. Considere também incluir uma opção de menu de contexto para "Abrir em uma nova janela".

Vejamos as etapas para criar uma nova vista. Aqui, a nova vista é iniciada em resposta a um clique no botão.

private async void Button_Click(object sender, RoutedEventArgs e)
{
    CoreApplicationView newView = CoreApplication.CreateNewView();
    int newViewId = 0;
    await newView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
    {
        Frame frame = new Frame();
        frame.Navigate(typeof(SecondaryPage), null);   
        Window.Current.Content = frame;
        // You have to activate the window in order to show it later.
        Window.Current.Activate();

        newViewId = ApplicationView.GetForCurrentView().Id;
    });
    bool viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(newViewId);
}

Para mostrar uma nova vista

  1. Chame CoreApplication.CreateNewView para criar uma nova janela e thread para o conteúdo da exibição.

    CoreApplicationView newView = CoreApplication.CreateNewView();

  2. Acompanhe o Id da nova exibição . Use isto para mostrar a vista mais tarde.

    Talvez você queira considerar a criação de alguma infraestrutura em seu aplicativo para ajudar no acompanhamento das exibições criadas. Consulte a classe ViewLifetimeControl no exemplo MultipleViews para um exemplo.

    int newViewId = 0;

  3. No novo tópico, preencha a janela.

    Use o método CoreDispatcher.RunAsync para agendar o trabalho no thread da interface do usuário para o novo modo de exibição. Você usa uma expressão lambda para passar uma função como um argumento para o método RunAsync . O trabalho que você faz na função lambda acontece no thread da nova exibição.

    Em XAML, você normalmente adiciona um Quadro à propriedade de Conteúdo da Janela e, em seguida, navega o Quadro para uma Página XAML onde você definiu o conteúdo do aplicativo. Para mais informações sobre quadros e páginas, veja Navegação par-a-par entre duas páginas.

    Depois de preencher o novo de Janela, deve-se chamar o método Activate da Janelade para mostrar mais tarde a Janela . Este trabalho acontece na thread da nova visualização, então a nova Janela é ativada.

    Por fim, obtenha o Id de do novo modo de exibição que será usado para mostrar a exibição mais tarde. Novamente, esse trabalho está no thread do novo modo de exibição, portanto, ApplicationView.GetForCurrentView obtém o Id do novo modo de exibição.

    await newView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
    Frame frame = new Frame();
    frame.Navigate(typeof(SecondaryPage), null);   
    Window.Current.Content = frame;
    // You have to activate the window in order to show it later.
    Window.Current.Activate();

    newViewId = ApplicationView.GetForCurrentView().Id;
});

  4. Mostrar o novo modo de exibição chamando ApplicationViewSwitcher.TryShowAsStandaloneAsync.

    Depois de criar um novo modo de exibição, você pode mostrá-lo em uma nova janela chamando o método ApplicationViewSwitcher.TryShowAsStandaloneAsync . O parâmetro viewId para esse método é um inteiro que identifica exclusivamente cada um dos modos de exibição em seu aplicativo. Você recupera a vista Id usando a propriedade ApplicationView.Id ou o método ApplicationView.GetApplicationViewIdForWindow .

    bool viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(newViewId);

A vista principal

A primeira vista criada quando a sua aplicação é iniciada é chamada de vista principal. Essa exibição é armazenada na propriedade CoreApplication.MainView, e sua propriedade IsMain é verdadeira. Você não cria esta vista; ela é criada pelo aplicativo. O thread da exibição principal serve como o gerenciador para o aplicativo, e todos os eventos de ativação do aplicativo são entregues nesse thread.

Se as visões secundárias estiverem abertas, a janela da vista principal pode ser ocultada – por exemplo, clicando no botão de fechar (x) na barra de título da janela – mas o seu thread permanece ativo. Chamar Fechar na janela do modo de exibição principal faz com que um InvalidOperationException de ocorra. (Use Application.Exit para fechar seu aplicativo.) Se o thread da visualização principal for encerrado, o aplicativo será fechado.

Vistas secundárias

Outros modos de exibição, incluindo todos os modos de exibição que você cria chamando CreateNewView no código do seu aplicativo, são modos de exibição secundários. As exibições principal e secundária são armazenadas na coleção CoreApplication.Views do . Normalmente, você cria exibições secundárias em resposta a uma ação do usuário. Em alguns casos, o sistema cria exibições secundárias para seu aplicativo.

Observação

Você pode usar a funcionalidade de acesso atribuído do Windows para executar uma aplicação no modo de quiosque . Quando você faz isso, o sistema cria uma exibição secundária para apresentar a interface do usuário do aplicativo acima da tela de bloqueio. As vistas secundárias criadas por aplicações não são permitidas, por isso, se tentar mostrar a sua própria vista secundária no modo de quiosque, é lançada uma exceção.

Mudar de uma vista para outra

Considere permitir uma maneira para o utilizador navegar de uma janela secundária de volta para a sua janela principal. Para fazer isso, use o método ApplicationViewSwitcher.SwitchAsync . Você chama esse método a partir do thread da janela da qual está alternando e passa a ID de exibição da janela para a qual está mudando.

await ApplicationViewSwitcher.SwitchAsync(viewIdToShow);

Ao usar SwitchAsync, você pode escolher se deseja fechar a janela inicial e removê-la da barra de tarefas especificando o valor de ApplicationViewSwitchingOptions.

  • Last updated on