Etapa 2: Configurar os manipuladores de eventos

Etapa 2: Configurar os manipuladores de eventos

[ Este artigo destina-se aos desenvolvedores do Windows 8.x e do Windows Phone 8.x que escrevem aplicativos do Windows Runtime. Se você estiver desenvolvendo para o Windows 10, consulte documentação mais recente ]

Para continuar a configurar o DirectX para mostrar um modo de exibição, vamos conectar os manipuladores aos eventos. Esta etapa se baseia no código que você já criou para o fluxo básico do seu aplicativo DirectX usando C++ e as APIs do Tempo de Execução do Windows na Etapa 1: criar e iniciar um modo de exibição.

O código usado nesta orientação foi tirado do modelo Aplicativo DirectX no Microsoft Visual Studio 2013. Ele pode ser encontrado nos arquivos App.h, App.cpp, DeviceResources.h e DeviceResources.cpp.

Instruções

Em Criar e iniciar um modo de exibição, você desenvolveu os métodos Initialize e SetWindow na classe de provedor de modo de exibição, que são chamados pelo aplicativo quando este é iniciado. Esses métodos obrigatórios anexam um novo modo de exibição e uma nova janela ao aplicativo, além de correlacionarem os manipuladores aos eventos PLM (Gerenciamento do Tempo de Vida do Processo) compatíveis ao aplicativo. O código fica assim:



// The first method called when the IFrameworkView is being created.
void App::Initialize(CoreApplicationView^ applicationView)
{
	// Register event handlers for app lifecycle. This example includes Activated, so that we
	// can make the CoreWindow active and start rendering on the window.
	applicationView->Activated +=
		ref new TypedEventHandler<CoreApplicationView^, IActivatedEventArgs^>(this, &App::OnActivated);

	CoreApplication::Suspending +=
		ref new EventHandler<SuspendingEventArgs^>(this, &App::OnSuspending);

	CoreApplication::Resuming +=
		ref new EventHandler<Platform::Object^>(this, &App::OnResuming);

	// At this point we have access to the device. 
	// We can create the device-dependent resources.
	m_deviceResources = std::make_shared<DeviceResources>();
}



// Called when the CoreWindow object is created (or re-created).
void App::SetWindow(CoreWindow^ window)
{
	window->SizeChanged += 
		ref new TypedEventHandler<CoreWindow^, WindowSizeChangedEventArgs^>(this, &App::OnWindowSizeChanged);

	window->VisibilityChanged +=
		ref new TypedEventHandler<CoreWindow^, VisibilityChangedEventArgs^>(this, &App::OnVisibilityChanged);

	window->Closed += 
		ref new TypedEventHandler<CoreWindow^, CoreWindowEventArgs^>(this, &App::OnWindowClosed);

	DisplayInformation^ currentDisplayInformation = DisplayInformation::GetForCurrentView();

	currentDisplayInformation->DpiChanged +=
		ref new TypedEventHandler<DisplayInformation^, Object^>(this, &App::OnDpiChanged);

	currentDisplayInformation->OrientationChanged +=
		ref new TypedEventHandler<DisplayInformation^, Object^>(this, &App::OnOrientationChanged);

	DisplayInformation::DisplayContentsInvalidated +=
		ref new TypedEventHandler<DisplayInformation^, Object^>(this, &App::OnDisplayContentsInvalidated);

	// Disable all pointer visual feedback for better performance when touching.
	auto pointerVisualizationSettings = PointerVisualizationSettings::GetForCurrentView();
	pointerVisualizationSettings->IsContactFeedbackEnabled = false; 
	pointerVisualizationSettings->IsBarrelButtonFeedbackEnabled = false;

	m_deviceResources->SetWindow(window);
}

Ele é correlacionado a um conjunto de eventos definido no cabeçalho do seu objeto de aplicativo principal. No arquivo de cabeçalho do seu aplicativo de modelo do Aplicativo DirectX (nesse caso, App.h):



// Application lifecycle event handlers.
		void OnActivated(Windows::ApplicationModel::Core::CoreApplicationView^ applicationView, Windows::ApplicationModel::Activation::IActivatedEventArgs^ args);
		void OnSuspending(Platform::Object^ sender, Windows::ApplicationModel::SuspendingEventArgs^ args);
		void OnResuming(Platform::Object^ sender, Platform::Object^ args);

		// Window event handlers.
		void OnWindowSizeChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::WindowSizeChangedEventArgs^ args);
		void OnVisibilityChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::VisibilityChangedEventArgs^ args);
		void OnWindowClosed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::CoreWindowEventArgs^ args);

		// Display properties event handlers.
		void OnDpiChanged(Windows::Graphics::Display::DisplayInformation^ sender, Platform::Object^ args);
		void OnOrientationChanged(Windows::Graphics::Display::DisplayInformation^ sender, Platform::Object^ args);
		void OnDisplayContentsInvalidated(Windows::Graphics::Display::DisplayInformation^ sender, Platform::Object^ args);


Neste código, você tem um manipulador para a ativação do modo de exibição: OnActivated. Ele é chamado quando o aplicativo ativa o modo de exibição, isto é, quando o modo de exibição do aplicativo está ativo no primeiro plano da exibição. Neste exemplo, o código simplesmente ativa a instância de CoreWindow associada. Temos também manipuladores para o PLM suspender e retomar eventos: OnSuspending e OnResuming.

Também há manipuladores para eventos de visibilidade e de alteração do tamanho de janelas:

  • OnVisibilityChanged é chamado quando a janela principal do aplicativo se move do primeiro plano ao segundo plano e vice-versa.
  • OnWindowSizeChanged é chamado quando muda o tamanho da exibição (janela).
  • OnWindowClosed é chamado quando o usuário fecha a janela.

Também há manipuladores para alguns eventos de exibição:

  • OnDpiChanged é chamado quando a DPI de exibição é alterada nas configurações de vídeo da área de trabalho clássica ou nas novas configurações de nível de colocação em escala para aplicativos da Windows Store.
  • OnOrientationChanged é chamado quando a orientação da tela muda de paisagem para retrato ou vice-versa. Esse é um evento importante a ser manipulado.
  • OnDisplayContentsInvalidated é chamado quando o dispositivo gráfico do Direct3D é perdido ou sofre alguma alteração.

Agora, implemente esses manipuladores.

Primeiro, defina o manipulador do evento de ativação do modo de exibição, OnActivated.


void App::OnActivated(CoreApplicationView^ applicationView, IActivatedEventArgs^ args)
{
	// Run() won't start until the CoreWindow is activated.
	CoreWindow::GetForCurrentThread()->Activate();
}


Conforme mencionado antes, você está simplesmente ativando a janela que o aplicativo forneceu à instância do provedor de modo de exibição. Caso esteja com criatividade, você poderá ampliar esse método para gerar uma tela inicial usando o objeto SplashScreen fornecido por IActivatedEventArgs.SplashScreen.

Agora, defina os comportamentos básicos quando OnSuspending e OnResuming são chamados pelos eventos PLM de suspensão e continuação, respectivamente.


void App::OnSuspending(Platform::Object^ sender, SuspendingEventArgs^ args)
{
	// Save app state asynchronously after requesting a deferral. Holding a deferral
	// indicates that the application is busy performing suspending operations. Be
	// aware that a deferral may not be held indefinitely. After about five seconds,
	// the app will be forced to exit.
	SuspendingDeferral^ deferral = args->SuspendingOperation->GetDeferral();

	create_task([this, deferral]()
	{
        m_deviceResources->Trim();

		// Insert your code here.

		deferral->Complete();
	});
}
 
void App::OnResuming(Platform::Object^ sender, Platform::Object^ args)
{
	// Restore any data or state that was unloaded on suspend. By default, data
	// and state are persisted when resuming from suspend. Note that this event
	// does not occur if the app was previously terminated.

	// Insert your code here.
}


Em seguida, escreva o código dos manipuladores de eventos da janela: OnWindowSizeChanged, OnVisibilityChanged e OnWindowClosed. (Veremos o que ocorre com os métodos de recursos do dispositivo na Etapa 3: conectar a cadeia de permuta do DirectX.


void App::OnWindowSizeChanged(CoreWindow^ sender, WindowSizeChangedEventArgs^ args)
{
	m_deviceResources->UpdateForWindowSizeChange();
	m_main->CreateWindowSizeDependentResources();
}




void App::OnVisibilityChanged(CoreWindow^ sender, VisibilityChangedEventArgs^ args)
{
	m_windowVisible = args->Visible;
}

void App::OnWindowClosed(CoreWindow^ sender, CoreWindowEventArgs^ args)
{
	m_windowClosed = true;
}




void App::OnWindowClosed(CoreWindow^ sender, CoreWindowEventArgs^ args)
{
	m_windowClosed = true;
}


Em OnWindowSizeChanged, você deve fornecer o código que recriará o tamanho de exibição da cadeia de permuta do DirectX quando a janela for redimensionada. Neste exemplo, é criado um método privado UpdateForWindowSizeChange, chamado no código anteriormente. A versão desse modelo encontra-se em DeviceResources.cpp, na implementação da classe DeviceResources.

Você deve atualizar os recursos gráficos quando o tamanho muda. Adicione um método como este à classe do provedor do modo de exibição (ou, neste caso, sua classe pai):


void DeviceResources::UpdateForWindowSizeChange()
{
	DisplayInformation^ currentDisplayInformation = DisplayInformation::GetForCurrentView();

	if (m_swapChainPanel == nullptr && (
            m_window->Bounds.Width  != m_outputSize.Width ||
            m_window->Bounds.Height != m_outputSize.Height
        ) || m_swapChainPanel != nullptr && (
            m_swapChainPanel->ActualWidth != m_outputSize.Width ||
            m_swapChainPanel->ActualHeight != m_outputSize.Height
        ) || m_orientation != currentDisplayInformation->CurrentOrientation)

	{
		CreateWindowSizeDependentResources();
	}
}

Abordaremos CreateWindowSizeDependentResources na etapa 3: conectar a cadeia de permuta do DirectX.

Etapa anterior

Criar e iniciar um modo de exibição

Próxima etapa

Conectar a cadeia de permuta do DirectX

Tópicos relacionados

Como configurar o seu aplicativo DirectX da Windows Store para mostrar uma visualização
Código completo de um aplicativo DirectX da Windows Store

 

 

Mostrar:
© 2017 Microsoft