#include "pch.h"
#include "LayoutAwarePage.h"
#include "SuspensionManager.h"

using namespace $safeprojectname$::Common;

using namespace Platform;
using namespace Platform::Collections;
using namespace Windows::Foundation;
using namespace Windows::Foundation::Collections;
using namespace Windows::System;
using namespace Windows::UI::Core;
using namespace Windows::UI::ViewManagement;
using namespace Windows::UI::Xaml;
using namespace Windows::UI::Xaml::Controls;
using namespace Windows::UI::Xaml::Interop;
using namespace Windows::UI::Xaml::Navigation;

/// <summary>
/// Initialisiert eine neue Instanz der <see cref="LayoutAwarePage"/>-Klasse.
/// </summary>
LayoutAwarePage::LayoutAwarePage()
{
	if (Windows::ApplicationModel::DesignMode::DesignModeEnabled)
	{
		return;
	}

	// Ein leeres Standardanzeigemodell erstellen
	DefaultViewModel = ref new Map<String^, Object^>(std::less<String^>());

	// Zwei Änderungen vornehmen, wenn diese Seite Teil der visuellen Struktur ist:
	// 1) Den Ansichtszustand der Anwendung dem visuellen Zustand für die Seite zuordnen
	// 2) Tastatur- und Mausnavigationsanforderungen bearbeiten
	Loaded += ref new RoutedEventHandler(this, &LayoutAwarePage::OnLoaded);

	// Dieselben Änderungen rückgängig machen, wenn die Seite nicht mehr sichtbar ist
	Unloaded += ref new RoutedEventHandler(this, &LayoutAwarePage::OnUnloaded);
}

DependencyProperty^ LayoutAwarePage::_defaultViewModelProperty = nullptr;

void LayoutAwarePage::RegisterDependencyProperties()
{
	if (_defaultViewModelProperty == nullptr)
	{
		_defaultViewModelProperty =
			DependencyProperty::Register("DefaultViewModel",
			TypeName(IObservableMap<String^, Object^>::typeid), TypeName(LayoutAwarePage::typeid), nullptr);
	}
}

/// <summary>
/// Identifiziert die <see cref="DefaultViewModel"/>-Abhängigkeitseigenschaft.
/// </summary>
DependencyProperty^ LayoutAwarePage::DefaultViewModelProperty::get()
{
	return _defaultViewModelProperty;
}

/// <summary>
/// Ruft eine Implementierung von <see cref="IObservableMap&lt;String, Object&gt;"/> ab, das als
/// triviales Anzeigemodell verwendet werden kann.
/// </summary>
IObservableMap<String^, Object^>^ LayoutAwarePage::DefaultViewModel::get()
{
	return safe_cast<IObservableMap<String^, Object^>^>(GetValue(DefaultViewModelProperty));
}

/// <summary>
/// Legt eine Implementierung von <see cref="IObservableMap&lt;String, Object&gt;"/> fest, das als
/// triviales Anzeigemodell verwendet werden kann.
/// </summary>
void LayoutAwarePage::DefaultViewModel::set(IObservableMap<String^, Object^>^ value)
{
	SetValue(DefaultViewModelProperty, value);
}

/// <summary>
/// Wird aufgerufen, wenn die Seite Teil der visuellen Struktur ist
/// </summary>
/// <param name="sender">Instanz, von der das Ereignis ausgelöst wurde.</param>
/// <param name="e">Ereignisdaten, die die Bedingungen beschreiben, die zu dem Ereignis geführt haben.</param>
void LayoutAwarePage::OnLoaded(Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
{
	this->StartLayoutUpdates(sender, e);

	// Tastatur- und Mausnavigation trifft nur zu, wenn das gesamte Fenster ausgefüllt wird.
	if (this->ActualHeight == Window::Current->Bounds.Height &&
		this->ActualWidth == Window::Current->Bounds.Width)
	{
		// Direkt am Fenster lauschen, sodass kein Fokus erforderlich ist
		_acceleratorKeyEventToken = Window::Current->CoreWindow->Dispatcher->AcceleratorKeyActivated +=
			ref new TypedEventHandler<CoreDispatcher^, AcceleratorKeyEventArgs^>(this,
			&LayoutAwarePage::CoreDispatcher_AcceleratorKeyActivated);
		_pointerPressedEventToken = Window::Current->CoreWindow->PointerPressed +=
			ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this,
			&LayoutAwarePage::CoreWindow_PointerPressed);
		_navigationShortcutsRegistered = true;
	}
}

/// <summary>
/// Wird aufgerufen, wenn die Seite aus der visuellen Struktur entfernt wird
/// </summary>
/// <param name="sender">Instanz, von der das Ereignis ausgelöst wurde.</param>
/// <param name="e">Ereignisdaten, die die Bedingungen beschreiben, die zu dem Ereignis geführt haben.</param>
void LayoutAwarePage::OnUnloaded(Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
{
	if (_navigationShortcutsRegistered)
	{
		Window::Current->CoreWindow->Dispatcher->AcceleratorKeyActivated -= _acceleratorKeyEventToken;
		Window::Current->CoreWindow->PointerPressed -= _pointerPressedEventToken;
		_navigationShortcutsRegistered = false;
	}
	StopLayoutUpdates(sender, e);
}

#pragma region Navigation support

/// <summary>
/// Wird aufgerufen als Ereignishandler, um rückwärts im mit der Seite verknüpften <see cref="Frame"/>
/// zu navigieren, bis der Anfang des Navigationsstapels erreicht wird.
/// </summary>
/// <param name="sender">Instanz, von der das Ereignis ausgelöst wurde.</param>
/// <param name="e">Ereignisdaten, die die Bedingungen beschreiben, die zu dem Ereignis geführt haben.</param>
void LayoutAwarePage::GoHome(Object^ sender, RoutedEventArgs^ e)
{
	(void) sender;	// Nicht verwendeter Parameter
	(void) e;	// Nicht verwendeter Parameter

	// Den Navigationsframe zum Zurückkehren zur obersten Seite verwenden
	if (Frame != nullptr)
	{
		while (Frame->CanGoBack)
		{
			Frame->GoBack();
		}
	}
}

/// <summary>
/// Wird aufgerufen als Ereignishandler, um rückwärts im Navigationsstapel zu navigieren,
/// der mit dem <see cref="Frame"/> dieser Seite verknüpft ist.
/// </summary>
/// <param name="sender">Instanz, von der das Ereignis ausgelöst wurde.</param>
/// <param name="e">Ereignisdaten, die die Bedingungen beschreiben, die zu dem Ereignis geführt haben.</param>
void LayoutAwarePage::GoBack(Object^ sender, RoutedEventArgs^ e)
{
	(void) sender;	// Nicht verwendeter Parameter
	(void) e;	// Nicht verwendeter Parameter

	// Den Navigationsframe zum Zurückkehren zur vorherigen Seite verwenden
	if (Frame != nullptr && Frame->CanGoBack)
	{
		Frame->GoBack();
	}
}

/// <summary>
/// Wird aufgerufen als Ereignishandler, um vorwärts im Navigationsstapelereignis
/// der mit dem <see cref="Frame"/> dieser Seite verknüpft ist.
/// </summary>
/// <param name="sender">Instanz, von der das Ereignis ausgelöst wurde.</param>
/// <param name="e">Ereignisdaten, die die Bedingungen beschreiben, die zu dem Ereignis geführt haben.</param>
void LayoutAwarePage::GoForward(Object^ sender, RoutedEventArgs^ e)
{
	(void) sender;	// Nicht verwendeter Parameter
	(void) e;	// Nicht verwendeter Parameter

	// Den Navigationsframe zum Wechseln zur nächsten Seite verwenden
	if (Frame != nullptr && Frame->CanGoForward)
	{
		Frame->GoForward();
	}
}

/// <summary>
/// Wird bei jeder Tastatureingabe aufgerufen, einschließlich Systemtasten wie ALT-Tastenkombinationen, wenn
/// diese Seite aktiv ist und das gesamte Fenster ausfüllt.  Wird verwendet zum Erkennen von Tastaturnavigation
/// zwischen Seiten, auch wenn sich die Seite selbst nicht im Fokus befindet.
/// </summary>
/// <param name="sender">Instanz, von der das Ereignis ausgelöst wurde.</param>
/// <param name="e">Ereignisdaten, die die Bedingungen beschreiben, die zu dem Ereignis geführt haben.</param>
void LayoutAwarePage::CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher^ sender,
															 AcceleratorKeyEventArgs^ e)
{
	auto virtualKey = e->VirtualKey;

	// Weitere Untersuchungen nur durchführen, wenn die Taste "Nach links", "Nach rechts" oder die dezidierten Tasten "Zurück" oder "Weiter"
	// gedrückt werden
	if ((e->EventType == CoreAcceleratorKeyEventType::SystemKeyDown ||
		e->EventType == CoreAcceleratorKeyEventType::KeyDown) &&
		(virtualKey == VirtualKey::Left || virtualKey == VirtualKey::Right ||
		(int)virtualKey == 166 || (int)virtualKey == 167))
	{
		auto coreWindow = Window::Current->CoreWindow;
		auto downState = Windows::UI::Core::CoreVirtualKeyStates::Down;
		bool menuKey = (coreWindow->GetKeyState(VirtualKey::Menu) & downState) == downState;
		bool controlKey = (coreWindow->GetKeyState(VirtualKey::Control) & downState) == downState;
		bool shiftKey = (coreWindow->GetKeyState(VirtualKey::Shift) & downState) == downState;
		bool noModifiers = !menuKey && !controlKey && !shiftKey;
		bool onlyAlt = menuKey && !controlKey && !shiftKey;

		if (((int)virtualKey == 166 && noModifiers) ||
			(virtualKey == VirtualKey::Left && onlyAlt))
		{
			// Wenn die Taste "Zurück" oder ALT+NACH-LINKS-TASTE gedrückt wird, zurück navigieren
			e->Handled = true;
			GoBack(this, ref new RoutedEventArgs());
		}
		else if (((int)virtualKey == 167 && noModifiers) ||
			(virtualKey == VirtualKey::Right && onlyAlt))
		{
			// Wenn die Taste "Weiter" oder ALT+NACH-RECHTS-TASTE gedrückt wird, vorwärts navigieren
			e->Handled = true;
			GoForward(this, ref new RoutedEventArgs());
		}
	}
}

/// <summary>
/// Wird bei jedem Mausklick, jeder Touchscreenberührung oder einer äquivalenten Interaktion aufgerufen, wenn diese
/// Seite aktiv ist und das gesamte Fenster ausfüllt.  Wird zum Erkennen von "Weiter"- und "Zurück"-Maustastenklicks
/// im Browserstil verwendet, um zwischen Seiten zu navigieren.
/// </summary>
/// <param name="sender">Instanz, von der das Ereignis ausgelöst wurde.</param>
/// <param name="e">Ereignisdaten, die die Bedingungen beschreiben, die zu dem Ereignis geführt haben.</param>
void LayoutAwarePage::CoreWindow_PointerPressed(CoreWindow^ sender, PointerEventArgs^ e)
{
	auto properties = e->CurrentPoint->Properties;

	// Tastenkombinationen mit der linken, rechten und mittleren Taste ignorieren
	if (properties->IsLeftButtonPressed || properties->IsRightButtonPressed ||
		properties->IsMiddleButtonPressed) return;

	// Wenn "Zurück" oder "Vorwärts" gedrückt wird (jedoch nicht gleichzeitig), entsprechend navigieren
	bool backPressed = properties->IsXButton1Pressed;
	bool forwardPressed = properties->IsXButton2Pressed;
	if (backPressed ^ forwardPressed)
	{
		e->Handled = true;
		if (backPressed) GoBack(this, ref new RoutedEventArgs());
		if (forwardPressed) GoForward(this, ref new RoutedEventArgs());
	}
}

#pragma endregion

#pragma region Visual state switching

/// <summary>
/// Wird aufgerufen als Ereignishandler, normalerweise für das <see cref="Loaded"/>-Ereignis von einem
/// <see cref="Control"/> innerhalb der Seite, um anzugeben, dass der Absender mit dem Empfang von
/// Änderungen der visuellen Zustandsverwaltung beginnen soll, die Änderungen am Ansichtszustand der Anwendung entsprechen.
/// </summary>
/// <param name="sender">Instanz von <see cref="Control"/>, die die Verwaltung von visuellen Zuständen
/// entsprechend den Ansichtszuständen unterstützt.</param>
/// <param name="e">Ereignisdaten, die beschreiben, wie die Anforderung durchgeführt wurde.</param>
/// <remarks>Der aktuelle Ansichtszustand wird sofort verwendet, um den entsprechenden visuellen Zustand festzulegen,
/// wenn Layoutaktualisierungen angefordert werden.  Ein entsprechender <see cref="Unloaded"/>-Ereignishandler,
/// der mit <see cref="StopLayoutUpdates"/> verbunden ist, wird dringend empfohlen.  Instanzen von
/// <see cref="LayoutAwarePage"/> rufen diese Handler in den zugehörigen Loaded- und Unloaded-Ereignissen
/// automatisch auf.</remarks>
/// <seealso cref="DetermineVisualState"/>
/// <seealso cref="InvalidateVisualState"/>
void LayoutAwarePage::StartLayoutUpdates(Object^ sender, RoutedEventArgs^ e)
{
	(void) e;	// Nicht verwendeter Parameter

	auto control = safe_cast<Control^>(sender);
	if (_layoutAwareControls == nullptr)
	{
		// Lauschen der Änderungen am Ansichtszustand starten, wenn an Aktualisierungen interessierte Steuerelemente vorliegen
		_layoutAwareControls = ref new Vector<Control^>();
		_windowSizeEventToken = Window::Current->SizeChanged += ref new WindowSizeChangedEventHandler(this, &LayoutAwarePage::WindowSizeChanged);

		// Seite empfängt Benachrichtigungen für untergeordnete Elemente. Die Seite schützen, bis die Layout-Updates für alle Steuerelemente abgeschlossen sind.
		_this = this;
	}
	_layoutAwareControls->Append(control);

	// Den anfänglichen visuellen Zustand des Steuerelements festlegen
	VisualStateManager::GoToState(control, DetermineVisualState(ApplicationView::Value), false);
}

void LayoutAwarePage::WindowSizeChanged(Object^ sender, Windows::UI::Core::WindowSizeChangedEventArgs^ e)
{
	(void) sender;	// Nicht verwendeter Parameter
	(void) e;	// Nicht verwendeter Parameter

	InvalidateVisualState();
}

/// <summary>
/// Wird aufgerufen als Ereignishandler, normalerweise für das <see cref="Unloaded"/>-Ereignis von einem
/// <see cref="Control"/>, um anzugeben, dass der Absender mit dem Empfang von
/// Änderungen der visuellen Zustandsverwaltung beginnen soll, die Änderungen am Ansichtszustand der Anwendung entsprechen.
/// </summary>
/// <param name="sender">Instanz von <see cref="Control"/>, die die Verwaltung von visuellen Zuständen
/// entsprechend den Ansichtszuständen unterstützt.</param>
/// <param name="e">Ereignisdaten, die beschreiben, wie die Anforderung durchgeführt wurde.</param>
/// <remarks>Der aktuelle Ansichtszustand wird sofort verwendet, um den entsprechenden visuellen Zustand festzulegen,
/// wenn Layoutaktualisierungen angefordert werden.</remarks>
/// <seealso cref="StartLayoutUpdates"/>
void LayoutAwarePage::StopLayoutUpdates(Object^ sender, RoutedEventArgs^ e)
{
	(void) e;	// Nicht verwendeter Parameter

	auto control = safe_cast<Control^>(sender);
	unsigned int index;
	if (_layoutAwareControls != nullptr && _layoutAwareControls->IndexOf(control, &index))
	{
		_layoutAwareControls->RemoveAt(index);
		if (_layoutAwareControls->Size == 0)
		{
			// Lauschen der Änderungen am Ansichtszustand beenden, wenn keine Steuerelemente an Aktualisierungen interessiert sind
			Window::Current->SizeChanged -= _windowSizeEventToken;
			_layoutAwareControls = nullptr;
			// Das letzte Steuerelement hat die "Unload"-Benachrichtigung erhalten.
			_this = nullptr;
		}
	}
}

/// <summary>
/// Übersetzt <see cref="ApplicationViewState"/>-Werte in Zeichenfolgen für die visuelle Zustandsverwaltung
/// innerhalb der Seite.  Die Standardimplementierung verwendet die Namen von Enumerationswerten.  Unterklassen können
/// diese Methode überschreiben, um das verwendete Zuordnungsschema zu steuern.
/// </summary>
/// <param name="viewState">Ansichtszustand, für den ein visueller Zustand gewünscht wird.</param>
/// <returns>Name des visuellen Zustands zur Verwendung mit dem <see cref="VisualStateManager"/></returns>
/// <seealso cref="InvalidateVisualState"/>
String^ LayoutAwarePage::DetermineVisualState(ApplicationViewState viewState)
{
	switch (viewState)
	{
	case ApplicationViewState::Filled:
		return "Filled";
	case ApplicationViewState::Snapped:
		return "Snapped";
	case ApplicationViewState::FullScreenPortrait:
		return "FullScreenPortrait";
	case ApplicationViewState::FullScreenLandscape:
	default:
		return "FullScreenLandscape";
	}
}

/// <summary>
/// Aktualisiert alle Steuerelemente, die auf Änderungen des visuellen Zustands lauschen, mit dem korrekten visuellen
/// Zustand.
/// </summary>
/// <remarks>
/// Wird normalerweise in Verbindung mit dem Überschreiben von <see cref="DetermineVisualState"/> verwendet, um
/// zu signalisieren, dass ein anderer Wert zurückgegeben kann, obwohl der Ansichtszustand nicht geändert wurde.
/// </remarks>
void LayoutAwarePage::InvalidateVisualState()
{
	if (_layoutAwareControls != nullptr)
	{
		String^ visualState = DetermineVisualState(ApplicationView::Value);
		auto controlIterator = _layoutAwareControls->First();
		while (controlIterator->HasCurrent)
		{
			auto control = controlIterator->Current;
			VisualStateManager::GoToState(control, visualState, false);
			controlIterator->MoveNext();
		}
	}
}

#pragma endregion

#pragma region Process lifetime management

/// <summary>
/// Wird aufgerufen, wenn diese Seite in einem Rahmen angezeigt werden soll.
/// </summary>
/// <param name="e">Ereignisdaten, die beschreiben, wie diese Seite erreicht wurde. Die
/// Parametereigenschaft stellt die anzuzeigende Gruppe bereit.</param>
void LayoutAwarePage::OnNavigatedTo(NavigationEventArgs^ e)
{
	auto frameState = SuspensionManager::SessionStateForFrame(Frame);
	_pageKey = "Page-" + Frame->BackStackDepth;

	if (e->NavigationMode == NavigationMode::New)
	{
		// Bestehenden Zustand für die Vorwärtsnavigation löschen, wenn dem Navigationsstapel eine neue
		// Seite hinzugefügt wird
		auto nextPageKey = _pageKey;
		int nextPageIndex = Frame->BackStackDepth;
		while (frameState->HasKey(nextPageKey))
		{
			frameState->Remove(nextPageKey);
			nextPageIndex++;
			nextPageKey = "Page-" + nextPageIndex;
		}

		// Den Navigationsparameter an die neue Seite übergeben
		LoadState(e->Parameter, nullptr);
	}
	else
	{
		// Den Navigationsparameter und den beibehaltenen Seitenzustand an die Seite übergeben,
		// dabei die gleiche Strategie verwenden wie zum Laden des angehaltenen Zustands und zum erneuten Erstellen von im Cache verworfenen
		// Seiten
		LoadState(e->Parameter, safe_cast<IMap<String^, Object^>^>(frameState->Lookup(_pageKey)));
	}
}

/// <summary>
/// Wird aufgerufen, wenn diese Seite nicht mehr in einem Rahmen angezeigt wird.
/// </summary>
/// <param name="e">Ereignisdaten, die beschreiben, wie diese Seite erreicht wurde. Die
/// Parametereigenschaft stellt die anzuzeigende Gruppe bereit.</param>
void LayoutAwarePage::OnNavigatedFrom(NavigationEventArgs^ e)
{
	auto frameState = SuspensionManager::SessionStateForFrame(Frame);
	auto pageState = ref new Map<String^, Object^>();
	SaveState(pageState);
	frameState->Insert(_pageKey, pageState);
}

/// <summary>
/// Füllt die Seite mit Inhalt auf, der bei der Navigation übergeben wird.  Gespeicherte Zustände werden ebenfalls
/// bereitgestellt, wenn eine Seite aus einer vorherigen Sitzung neu erstellt wird.
/// </summary>
/// <param name="navigationParameter">Der Parameterwert, der an
/// <see cref="Frame.Navigate(Type, Object)"/> übergeben wurde, als diese Seite ursprünglich angefordert wurde.
/// </param>
/// <param name="pageState">Ein Übersicht des Zustands, der von dieser Seite während einer früheren Sitzung
/// beibehalten wurde.  Beim ersten Aufrufen einer Seite ist dieser Wert NULL.</param>
void LayoutAwarePage::LoadState(Object^ navigationParameter, IMap<String^, Object^>^ pageState)
{
}

/// <summary>
/// Behält den dieser Seite zugeordneten Zustand bei, wenn die Anwendung angehalten oder
/// die Seite im Navigationscache verworfen wird. Die Werte müssen den Serialisierungsanforderungen
/// von <see cref="SuspensionManager.SessionState"/> entsprechen.
/// </summary>
/// <param name="pageState">Eine leere Übersicht, die mit dem serialisierbaren Zustand aufgefüllt wird.</param>
void LayoutAwarePage::SaveState(IMap<String^, Object^>^ pageState)
{
}

#pragma endregion