//
// $safeitemname$.xaml.cpp
// Implementierung der $safeitemname$-Klasse
//

#include "pch.h"
#include "$safeitemname$.xaml.h"

using namespace $rootnamespace$;
using namespace $rootnamespace$::Common;

using namespace Platform;
using namespace Platform::Collections;
using namespace concurrency;
using namespace Windows::Foundation;
using namespace Windows::Foundation::Collections;
using namespace Windows::UI::ViewManagement;
using namespace Windows::UI::Xaml;
using namespace Windows::UI::Xaml::Controls;
using namespace Windows::UI::Xaml::Controls::Primitives;
using namespace Windows::UI::Xaml::Data;
using namespace Windows::UI::Xaml::Input;
using namespace Windows::UI::Xaml::Interop;
using namespace Windows::UI::Xaml::Media;
using namespace Windows::UI::Xaml::Navigation;

// Die Elementvorlage "Geteilte Seite" ist unter http://go.microsoft.com/fwlink/?LinkId=234234 dokumentiert.

$wizardregistrationcomment$$safeitemname$::$safeitemname$()
{
	InitializeComponent();
	SetValue(_defaultViewModelProperty, ref new Map<String^,Object^>(std::less<String^>()));
	auto navigationHelper = ref new Common::NavigationHelper(this,
		ref new Common::RelayCommand(
		[this](Object^) -> bool
	{
		return CanGoBack();
	},
		[this](Object^) -> void
	{
		GoBack();
	}
	)
		);
	SetValue(_navigationHelperProperty, navigationHelper);
	navigationHelper->LoadState += ref new Common::LoadStateEventHandler(this, &$safeitemname$::LoadState);
	navigationHelper->SaveState += ref new Common::SaveStateEventHandler(this, &$safeitemname$::SaveState);

	itemListView->SelectionChanged += ref new SelectionChangedEventHandler(this, &$safeitemname$::ItemListView_SelectionChanged);
	Window::Current->SizeChanged += ref new WindowSizeChangedEventHandler (this, &$safeitemname$::Window_SizeChanged);
	InvalidateVisualState();

}

DependencyProperty^ $safeitemname$::_navigationHelperProperty = nullptr;
DependencyProperty^ $safeitemname$::_defaultViewModelProperty = nullptr;

void $safeitemname$::RegisterDependencyProperties()
{
	if (_navigationHelperProperty == nullptr)
	{
		_navigationHelperProperty = DependencyProperty::Register("NavigationHelper",
			TypeName(Common::NavigationHelper::typeid), TypeName($safeitemname$::typeid), nullptr);
	}

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

/// <summary>
/// triviales Anzeigemodell verwendet werden kann.
/// </summary>
IObservableMap<String^, Object^>^ $safeitemname$::DefaultViewModel::get()
{
	return safe_cast<IObservableMap<String^, Object^>^>(GetValue(_defaultViewModelProperty));
}

/// <summary>
/// Ruft eine Implementierung von <see cref="NavigationHelper"/> ab, das als
/// triviales Anzeigemodell verwendet werden kann.
/// </summary>
Common::NavigationHelper^ $safeitemname$::NavigationHelper::get()
{
	//	return _navigationHelper;
	return safe_cast<Common::NavigationHelper^>(GetValue(_navigationHelperProperty));
}

#pragma region Page state management

/// <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 $safeitemname$::LoadState(Platform::Object^ sender, Common::LoadStateEventArgs^ e)
{
	// TODO: Mit DefaultViewModel->Insert("Group", <value>) eine bindbare Gruppe festlegen
	// TODO: Mit DefaultViewModel->Insert("Items", <value>) eine Auflistung von bindbaren Elementen festlegen

	if (e->PageState == nullptr)
	{
		// Wenn es sich hierbei um eine neue Seite handelt, das erste Element automatisch auswählen, außer wenn
		// logische Seitennavigation verwendet wird (weitere Informationen in der #Region zur logischen Seitennavigation unten).
		if (!UsingLogicalPageNavigation() && itemsViewSource->View != nullptr)
		{
			itemsViewSource->View->MoveCurrentToFirst();
		}
	}
	else
	{
		// Den zuvor gespeicherten Zustand wiederherstellen, der dieser Seite zugeordnet ist
		if (e->PageState->HasKey("SelectedItem") && itemsViewSource->View != nullptr)
		{
			// TODO: itemsViewSource->View->MoveCurrentTo() mit dem ausgewählten
			//       Element aufrufen, wie durch den Wert von pageState->Lookup("SelectedItem") angegeben
		}
	}
}

/// <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="sender">Die Quelle des Ereignisses, normalerweise <see cref="NavigationHelper"/></param>
/// <param name="e">Ereignisdaten, die ein leeres Wörterbuch zum Auffüllen bereitstellen
/// serialisierbarer Zustand.</param>
void $safeitemname$::SaveState(Platform::Object^ sender, Common::SaveStateEventArgs^ e)
{
	if (itemsViewSource->View != nullptr)
	{
		auto selectedItem = itemsViewSource->View->CurrentItem;
		// TODO: Einen serialisierbaren Navigationsparameter ableiten und ihn an
		//       pageState->Insert("SelectedItem", <Wert>) übergeben
	}
}

#pragma endregion

#pragma region Logical page navigation

// Die visuelle Zustandsverwaltung gibt die vier Ansichtszustände für Anwendungen normalerweise direkt wieder (Vollbild
// im Querformat und Hochformat sowie angedockte und gefüllte Ansicht). Die geteilte Seite wurde so entworfen,
// dass die angedockte Ansicht und das Querformat jeweils über zwei verschiedene Unterzustände verfügen: entweder die Elementliste
// oder die Details werden angezeigt, jedoch nicht beides gleichzeitig.
//
// All dies wird mit einer einzigen physischen Seite implementiert, die zwei logische Seiten darstellen kann.
// Mit dem nachfolgenden Code wird dieses Ziel erreicht, ohne dass der Benutzer den Unterschied bemerkt.

/// <summary>
/// Wird aufgerufen, um zu bestimmen, ob die Seite als eine logische Seite oder zwei agieren soll.
/// </summary>
/// <returns>"True", wenn der aktuelle Ansichtszustand Hochformat oder angedockt ist, "false"
/// in anderen Fällen.</returns>
bool $safeitemname$::CanGoBack()
{
	if (UsingLogicalPageNavigation() && itemListView->SelectedItem != nullptr)
	{
		return true;
	}
	else
	{
		return NavigationHelper->CanGoBack();
	}
}

void $safeitemname$::GoBack()
{
	if (UsingLogicalPageNavigation() && itemListView->SelectedItem != nullptr)
	{
		// Wenn die logische Seitennavigation wirksam ist und ein ausgewähltes Element vorliegt, werden die
		// Details dieses Elements aktuell angezeigt.  Beim Aufheben der Auswahl wird die
		// Elementliste wieder aufgerufen.  Aus Sicht des Benutzers ist dies eine logische
		// Rückwärtsnavigation.
		itemListView->SelectedItem = nullptr;
	}
	else
	{
		NavigationHelper->GoBack();
	}
}

/// <summary>
/// Mit der Änderung der Fenstergröße aufgerufen
/// </summary>
/// <param name="sender">Das aktuelle Fenster</param>
/// <param name="e">Ereignisdaten, die die neue Größe des Fensters beschreiben</param>
void $safeitemname$::Window_SizeChanged(Platform::Object^ sender, Windows::UI::Core::WindowSizeChangedEventArgs^ e)
{
	InvalidateVisualState();
}

/// <summary>
/// Wird aufgerufen, wenn ein Element innerhalb der Liste ausgewählt wird.
/// </summary>
/// <param name="sender">Die GridView, die das ausgewählte Element anzeigt.</param>
/// <param name="e">Ereignisdaten, die beschreiben, wie die Auswahl geändert wurde.</param>
void $safeitemname$::ItemListView_SelectionChanged(Platform::Object^ sender, Windows::UI::Xaml::Controls::SelectionChangedEventArgs^ e)
{
	if (UsingLogicalPageNavigation())
	{
		InvalidateVisualState();
	}
}

/// <summary>
/// Wird aufgerufen, um zu bestimmen, ob die Seite als eine logische Seite oder zwei agieren soll.
/// </summary>
/// <returns>True, wenn das Fenster als eine logische Seite fungieren soll, false
/// in anderen Fällen.</returns>
bool $safeitemname$::UsingLogicalPageNavigation()
{
	return Windows::UI::Xaml::Window::Current->Bounds.Width < MinimumWidthForSupportingTwoPanes;
}

void $safeitemname$::InvalidateVisualState()
{
	auto visualState = DetermineVisualState();
	Windows::UI::Xaml::VisualStateManager::GoToState(this, visualState, false);
	NavigationHelper->GoBackCommand->RaiseCanExecuteChanged();
}

/// <summary>
/// Wird aufgerufen, um den Namen des visuellen Zustands zu bestimmen, der dem Ansichtszustand einer Anwendung
/// entspricht.
/// </summary>
/// <returns>Der Name des gewünschten visuellen Zustands.  Dieser ist identisch mit dem Namen des
/// Ansichtszustands, außer wenn ein ausgewähltes Element im Hochformat und in der angedockten Ansicht vorliegt, wobei
/// diese zusätzliche logische Seite durch Hinzufügen des Suffix _Detail dargestellt wird.</returns>
Platform::String^ $safeitemname$::DetermineVisualState()
{
	if (!UsingLogicalPageNavigation())
		return "PrimaryView";

	// Den Aktivierungszustand der Schaltfläche "Zurück" aktualisieren, wenn der Ansichtszustand geändert wird
	auto logicalPageBack = UsingLogicalPageNavigation() && itemListView->SelectedItem != nullptr;

	return logicalPageBack ? "SinglePane_Detail" : "SinglePane";
}

#pragma endregion

#pragma region Navigation support

/// Die in diesem Abschnitt bereitgestellten Methoden werden einfach verwendet,
/// damit NavigationHelper auf die Navigationsmethoden der Seite reagieren kann.
/// 
/// Platzieren Sie seitenspezifische Logik in Ereignishandlern für  
/// <see cref="NavigationHelper::LoadState"/>
/// und <see cref="NavigationHelper::SaveState"/>.
/// Der Navigationsparameter ist in der LoadState-Methode zusätzlich 
/// zum Seitenzustand verfügbar, der während einer früheren Sitzung gesichert wurde.

void $safeitemname$::OnNavigatedTo(NavigationEventArgs^ e)
{
	NavigationHelper->OnNavigatedTo(e);
}

void $safeitemname$::OnNavigatedFrom(NavigationEventArgs^ e)
{
	NavigationHelper->OnNavigatedFrom(e);

}
#pragma endregion