// *** Private Methods ***
private TestableNavigationManager CreateNavigationManager(INavigationTarget navigationTarget = null, IViewFactory viewFactory = null, INavigationStack navigationStack = null, ILifetimeManager lifetimeManager = null, IStorageManager storageManager = null, bool navigationTargetIsNull = false)
{
if (navigationTarget == null && !navigationTargetIsNull)
{
navigationTarget = new MockNavigationTarget();
}
if (viewFactory == null)
{
viewFactory = MockViewFactory.WithPageAndViewModel;
}
if (navigationStack == null)
{
navigationStack = new MockNavigationStack();
}
if (lifetimeManager == null)
{
lifetimeManager = new MockLifetimeManager();
}
if (storageManager == null)
{
storageManager = new MockStorageManager();
}
TestableNavigationManager navigationManager = new TestableNavigationManager(navigationTarget, viewFactory, navigationStack, lifetimeManager, storageManager);
return(navigationManager);
}
public static void Recalculate(INavigationTarget target) {
cellSize = target.CellSize;
width = target.XCells;
height = target.ZCells;
maxHeight = target.MaxHeight;
maxSlope = target.MaxSlope;
worldOffset = new Vector3(-width * cellSize / 2f, 0, -height * cellSize / 2f);
linearCost = cellSize;
diagonalCost = (float)Math.Sqrt(2) * cellSize;
var halfCell = new Vector3(cellSize / 2, 0, cellSize / 2);
cells = new Cell[width, height];
// Scan the area of the mesh from above to find the walkable parts
int xLength = cells.GetLength(0);
int zLength = cells.GetLength(1);
for (int x = 0; x < xLength; x++) {
for (int z = 0; z < zLength; z++) {
cells[x, z] = new Cell {
Center = worldOffset + new Vector3(x * cellSize, maxHeight, z * cellSize) + halfCell,
X = x,
Z = z
};
target.SetCellIntersections(cells[x, z]);
}
}
}
public override object GenerateDataForTarget(INavigationTarget target, Dispatcher dispatcher)
{
var t = (DetailsNavigationTarget)target;
var rv = new DetailsViewModel(dispatcher, t.Param);
return(rv);
}
private IController InternalNavigate(IController currentRealTarget, INavigationTarget navigationTarget)
{
if (this.CurrentTargetDeniesNavigation(currentRealTarget))
{
return(this.CurrentContentController);
}
// Resolve the next Target
var nextContent = this.ResolveNextNavigationTarget(navigationTarget);
if (nextContent == null)
{
throw new NavigationTargetNotFoundException();
}
this.CurrentTarget = navigationTarget;
this.CurrentContentController = nextContent;
this._navigatedSubject.OnNext(new NavigationPayload(nextContent, navigationTarget));
INavigationJournalEntry journalEntry = new NavigationJournalEntry(navigationTarget);
this.Journal.RecordNavigation(journalEntry);
currentRealTarget?.Close();
return(this.CurrentContentController);
}
public override object GenerateDataForTarget(INavigationTarget target, Dispatcher dispatcher)
{
var t = (IndexNavigationTarget)target;
var rv = new IndexViewModel(dispatcher);
return(rv);
}
private string CreateUrl(Route route, INavigationTarget uriInfo)
{
var url = _scheme + route.UrlPattern;
var props = GetPropertiesHierarchical(uriInfo.GetType());
var routeVars = route.CreateSegments().Where(x => x.IsVariable).Select(x => x.Segment.ToLowerInvariant());
foreach (var prop in props)
{
if (routeVars.Contains(prop.Name.ToLowerInvariant()))
{
var value = Uri.EscapeDataString(prop.GetValue(uriInfo) + "");
url = url.Replace("{" + prop.Name.ToLowerInvariant() + "}", value);
}
//else if (prop.PropertyType == typeof(string) || prop.PropertyType.GetTypeInfo().IsValueType)
//{
// // querystring parameters ?id=x&id2=y
// var value = Uri.EscapeDataString((string)prop.GetValue(uriInfo));
// // building querystring parameters. If a ? already occurs, add a parameter with &, else add the first parameter with ?
// if (url.Contains("?"))
// {
// url += "&";
// }
// else
// {
// url += "?";
// }
// url += $"{prop.Name.ToLowerInvariant()}={value}";
//}
}
return(url);
}
public virtual bool Equals(INavigationTarget other)
{
if (other == null)
{
return(false);
}
return(this.NavigationTargetId == other.NavigationTargetId);
}
private Route FindRouteOrDefault(INavigationTarget target)
{
var route = _routes.FirstOrDefault(x => x.TargetType == target.GetType());
if (route == null)
{
return(_routes.Last()); // default route (home)
}
return(route);
}
internal static async Task OnNavigatingFromAsync(this INavigationTarget target)
{
if (target == null)
{
return;
}
var args = new NavigationCancelArgs();
target.OnNavigatingFrom(args);
await args.Task;
}
internal static async Task OnNavigatedFromAsync(this INavigationTarget target, object parameter)
{
if (target == null)
{
return;
}
var args = new NavigationArgs(parameter);
target.OnNavigatedFrom(args);
await args.Task;
}
// *** Constructors ***
public NavigationManager(INavigationTarget navigationTarget, IViewFactory viewFactory, ILifetimeManager lifetimeManager, IStorageManager storageManager
#if !NETFX_CORE
, IFileSystem fileSystem
#endif
)
: this(navigationTarget, viewFactory, lifetimeManager, storageManager
#if !NETFX_CORE
, fileSystem
#endif
, new NavigationStackWithHome())
{
}
public IController NavigateInCurrentNavigator(INavigationTarget navigationTarget)
{
var currentActiveNavigator = this.ViewModel.CurrentActiveNavigator;
if (currentActiveNavigator != null)
{
var controllerForViewModel =
this._navigatorControllers.Single(nc => nc.ViewModel == currentActiveNavigator);
return(controllerForViewModel.NavigateToTarget(navigationTarget));
}
return(null);
}
private void ToTarget(INavigationTarget target)
{
Navigated?.Invoke(this, target);
switch (target)
{
case ListTarget l:
SelectedListChanged?.Invoke(this, l.ListId);
break;
default:
break;
}
}
private void OnNavigated(object sender, INavigationTarget target)
{
var url = _urlSerializer.CreateUrl(target);
var route = _urlSerializer.FindRouteOrDefault(url);
if (_oldPageType != route.PageType)
{
_oldPageType = route.PageType;
_frame.DataContext = route.PageViewModelFactory?.Invoke(); // if the factory is null, the datacontext will be set to null
}
_frame.Navigate(route.PageType, url);
ApplicationView.GetForCurrentView().Title = url;
}
public NavigationManager([Import(AllowDefault = true)]INavigationTarget navigationTarget, IViewFactory viewFactory, ILifetimeManager lifetimeManager, IStorageManager storageManager)
{
this.viewFactory = viewFactory;
this.storageManager = storageManager;
// Use a default INavigationTarget if not specified
if (navigationTarget != null)
this.navigationTarget = navigationTarget;
else
this.navigationTarget = new WindowNavigationTarget();
// Register with the LifetimeManager
lifetimeManager.Register(this);
}
// *** Constructors ***
public NavigationManager(INavigationTarget navigationTarget, IViewFactory viewFactory, ILifetimeManager lifetimeManager, IStorageManager storageManager)
: base(viewFactory)
{
this.storageManager = storageManager;
// Use a default INavigationTarget if not specified
if (navigationTarget != null)
this.navigationTarget = navigationTarget;
else
this.navigationTarget = new WindowNavigationTarget();
// Register with the LifetimeManager
lifetimeManager.Register(this);
}
/// <summary>
/// Loads data to <see cref="Shell"/> and keeps data used for navigation in <see cref="Shell"/>.
/// </summary>
/// <param name="navMode">Navigation mode</param>
/// <param name="config">Navigation config</param>
/// <param name="target">Navigation target</param>
/// <param name="data">Data for <see cref="Shell"/></param>
internal void Load(NavigationMode navMode, INavigationConfig <INavigationTarget> config, INavigationTarget target, object data)
{
Mode = navMode;
Config = config;
Target = target;
Data = data;
var navigatable = Data as INavigatable;
if (navigatable != null)
{
navigatable.RequestClose += NavigatableOnRequestClose;
}
UnloadView();
View = Shell.SetContent(data, target?.GetType());
IsLoaded = true;
}
internal static void LoadState(this INavigationTarget target, Frame frame, NavigationEventArgs eventArgs)
{
if (target == null)
{
return;
}
// Returning to a cached page through navigation shouldn't trigger state loading
if (target.PageKey != null)
{
return;
}
var frameState = SuspensionManager.SessionStateForFrame(frame);
target.PageKey = "Page-" + frame.BackStackDepth;
var sharedState = frameState.ContainsKey("Shared")
? (Dictionary <String, Object>)frameState["Shared"]
: new Dictionary <string, object>();
if (eventArgs.NavigationMode == NavigationMode.New)
{
// Clear existing state for forward navigation when adding a new page to the
// navigation stack
var nextPageKey = target.PageKey;
var nextPageIndex = frame.BackStackDepth;
while (frameState.Remove(nextPageKey))
{
nextPageIndex++;
nextPageKey = "Page-" + nextPageIndex;
}
// Pass the navigation parameter to the new page
target.LoadState(eventArgs.Parameter, null, sharedState);
}
else
{
// Pass the navigation parameter and preserved page state to the page, using
// the same strategy for loading suspended state and recreating pages discarded
// from cache
object pageState;
frameState.TryGetValue(target.PageKey, out pageState);
target.LoadState(eventArgs.Parameter, (Dictionary <String, Object>)pageState, sharedState);
}
}
internal static void SaveState(this INavigationTarget target, Frame frame)
{
if (target == null)
{
return;
}
var frameState = SuspensionManager.SessionStateForFrame(frame);
var sharedState = frameState.ContainsKey("Shared")
? (Dictionary <String, Object>)frameState["Shared"]
: new Dictionary <string, object>();
var pageState = new Dictionary <String, Object>();
target.SaveState(pageState, sharedState);
frameState[target.PageKey] = pageState;
frameState["Shared"] = sharedState;
}
// *** Constructors ***
public NavigationManager(INavigationTarget navigationTarget, IViewFactory viewFactory, ILifetimeManager lifetimeManager, IStorageManager storageManager)
: base(viewFactory)
{
this.storageManager = storageManager;
// Use a default INavigationTarget if not specified
if (navigationTarget != null)
{
this.navigationTarget = navigationTarget;
}
else
{
this.navigationTarget = new WindowNavigationTarget();
}
// Register with the LifetimeManager
lifetimeManager.Register(this);
}
protected NavigationManager(INavigationTarget navigationTarget, IViewFactory viewFactory, ILifetimeManager lifetimeManager, IStorageManager storageManager
#if !NETFX_CORE
, IFileSystem fileSystem
#endif
, INavigationStack navigationStack)
: base(viewFactory, navigationStack)
{
if (lifetimeManager == null)
throw new ArgumentNullException(nameof(lifetimeManager));
if (storageManager == null)
throw new ArgumentNullException(nameof(storageManager));
_storageManager = storageManager;
#if !NETFX_CORE
if (fileSystem == null)
throw new ArgumentNullException(nameof(fileSystem));
_fileSystem = fileSystem;
#endif
// Use a default INavigationTarget if not specified
if (navigationTarget != null)
_navigationTarget = navigationTarget;
else
#if NETFX_CORE
_navigationTarget = new WindowNavigationTarget();
#else
_navigationTarget = new NavigationViewNavigationTarget();
#endif
// Register with the LifetimeManager
lifetimeManager.Register(this);
}
private IController ResolveNextNavigationTarget(INavigationTarget navigationTarget)
{
return(this._controllerFactory.CreateAndInitializeController(
navigationTarget.NavigationTargetControllerType));
}
public IController Navigate(INavigationTarget target)
{
return(this.InternalNavigate(this.CurrentContentController, target));
}
public bool ContainsNavigationTarget(INavigationTarget navigationTarget)
{
return(this.CurrentEntry.NavigationTarget.Equals(navigationTarget) ||
this.BackNavigationHistory.Any(nav => nav.NavigationTarget.Equals(navigationTarget)));
}
/// <inheritdoc /> public virtual bool MatchesTarget(INavigationTarget target) => true;
/// <inheritdoc />
public bool TryHandleNavigation(INavigationTarget target, object data)
{
throw new NotImplementedException();
}
// *** Constructors ***
public TestableNavigationManager(INavigationTarget navigationTarget, IViewFactory viewFactory, INavigationStack navigationStack, ILifetimeManager lifetimeManager, IStorageManager storageManager)
: base(navigationTarget, viewFactory, lifetimeManager, storageManager, navigationStack)
{
}
/// <inheritdoc /> public virtual NavigationMode GetNavigationMode(INavigationTarget target) => NavigationMode.Default;
/// <inheritdoc /> public virtual bool CanLeave(INavigationTarget target) => true;
public NavigationJournalEntry(INavigationTarget navigationTarget)
{
this.NavigationTarget = navigationTarget;
}
public IController NavigateInCurrentNavigatorTo(INavigationTarget navigationTarget)
{
return(this._contentBrowserController.NavigateInCurrentNavigator(navigationTarget));
}
public string CreateUrl(INavigationTarget target)
{
var route = FindRouteOrDefault(target);
return(CreateUrl(route, target));
}
private void NavigationOnNavigationFailed(NavigationFailReason reason, INavigationTarget target)
{
MessageBox.Show(reason.ToString(), "Navigation failed.");
}
/// <inheritdoc /> public abstract object GenerateDataForTarget(INavigationTarget target, Dispatcher dispatcher);
// *** Private Methods ***
private TestableNavigationManager CreateNavigationManager(INavigationTarget navigationTarget = null, IViewFactory viewFactory = null, INavigationStack navigationStack = null, ILifetimeManager lifetimeManager = null, IStorageManager storageManager = null, bool navigationTargetIsNull = false)
{
if (navigationTarget == null && !navigationTargetIsNull)
navigationTarget = new MockNavigationTarget();
if (viewFactory == null)
viewFactory = MockViewFactory.WithPageAndViewModel;
if (navigationStack == null)
navigationStack = new MockNavigationStack();
if (lifetimeManager == null)
lifetimeManager = new MockLifetimeManager();
if (storageManager == null)
storageManager = new MockStorageManager();
TestableNavigationManager navigationManager = new TestableNavigationManager(navigationTarget, viewFactory, navigationStack, lifetimeManager, storageManager);
return navigationManager;
}
public IController NavigateInCurrentNavigator(INavigationTarget navigationTarget)
{
return(this._shellController.NavigateInCurrentNavigatorTo(navigationTarget));
}
public NavigationRequest(INavigationTarget navigationTarget)
{
this.NavigationTarget = navigationTarget;
}
