public override void Execute([NotNull] INavigationParameter parameter, Action <NavigationResult> navigationCallback)
{
if (parameter == null)
{
return;
}
var command = parameter as CommandNavigationParameter;
if (command != null)
{
ExecuteCommand(command);
}
else if (parameter is RegionNavigationParameter)
{
ExecuteRegion((RegionNavigationParameter)parameter);
}
else if (parameter is ActionNavigationParameter)
{
ExecuteAction((ActionNavigationParameter)parameter);
}
else
{
throw new NotSupportedException(parameter.GetType().FullName);
}
}
/// <inheritdoc/>
public IObservable <Unit> PushPopup(
INavigable viewModel,
INavigationParameter navigationParameter,
string?contract = null,
bool animate = true)
{
if (viewModel == null)
{
throw new ArgumentNullException(nameof(viewModel));
}
if (navigationParameter == null)
{
throw new ArgumentNullException(nameof(navigationParameter));
}
return(Observable
.Start(() => LocatePopupFor(viewModel, contract), CurrentThreadScheduler.Instance)
.ObserveOn(CurrentThreadScheduler.Instance)
.Do(popup =>
popup.ViewModel.InvokeViewModelAction <INavigating>(x => x.WhenNavigatingTo(navigationParameter)))
.Select(popup =>
Observable
.FromAsync(() => _popupNavigation.PushAsync(popup, animate))
.Do(_ => popup.ViewModel.InvokeViewModelAction <INavigated>(x =>
x.WhenNavigatedTo(navigationParameter))))
.Switch()
.Do(_ =>
{
AddToStackAndTick(PopupSubject, viewModel, false);
Logger.Debug($"Added page '{viewModel.Id}' (contract '{contract}') to stack.");
}));
}
/// <inheritdoc />
public IObservable <Unit> PushPage(
INavigable navigableViewModel,
INavigationParameter parameter,
string contract = null,
bool resetStack = false,
bool animate = true)
{
if (navigableViewModel == null)
{
throw new ArgumentNullException(nameof(navigableViewModel));
}
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
return(View
.PushPage(navigableViewModel, contract, resetStack, animate)
.Do(_ =>
{
navigableViewModel
.WhenNavigatingTo(parameter)
.ObserveOn(View.MainThreadScheduler)
.Subscribe(navigating => Logger.Debug($"Called `WhenNavigatingTo` on '{navigableViewModel.Id}' passing parameter {parameter}"));
AddToStackAndTick(PageSubject, navigableViewModel, resetStack);
Logger.Debug($"Added page '{navigableViewModel.Id}' (contract '{contract}') to stack.");
navigableViewModel
.WhenNavigatedTo(parameter)
.ObserveOn(View.MainThreadScheduler)
.Subscribe(navigated => Logger.Debug($"Called `WhenNavigatedTo` on '{navigableViewModel.Id}' passing parameter {parameter}"));
}));
}
protected override IObservable <Unit> WhenNavigatingTo(INavigationParameter parameter)
{
if (parameter.TryGetValue("Id", out var id))
{
CoffeeId = id as Guid?;
}
return(Observable.Return(Unit.Default));
}
/// <inheritdoc/>
public IObservable<Unit> PushPopup<TViewModel>(
INavigationParameter navigationParameter,
string? contract = null,
bool animate = true)
where TViewModel : INavigable
{
var viewModel = Factory.Create<TViewModel>(contract);
return PushPopup(viewModel, navigationParameter, contract, animate);
}
public async Task ToModalPage(string page, INavigationParameter parameter)
{
var view = pages[page]();
modalWindow = new Window();
modalWindow.Content = view;
await Initialize(view, parameter).ConfigureAwait(false);
modalWindow.ShowDialog();
}
public async virtual Task CallNavigatingToAsync(INavigatingAware vm, INavigationParameter parameter, NavigationModes mode)
{
this.LogInfo();
if (vm == null)
{
return;
}
await vm.OnNavigatingToAsync(parameter, mode);
}
/// <inheritdoc/>
public IObservable<Unit> PushPopup(
INavigable viewModel,
INavigationParameter navigationParameter,
string? contract = null,
bool animate = true) =>
Observable.Create<Unit>(observer =>
{
if (viewModel == null)
{
throw new ArgumentNullException(nameof(viewModel));
}
if (navigationParameter == null)
{
throw new ArgumentNullException(nameof(navigationParameter));
}
var compositeDisposable = new CompositeDisposable();
Observable
.Start(() => LocatePopupFor(viewModel, contract), CurrentThreadScheduler.Instance)
.ObserveOn(CurrentThreadScheduler.Instance)
.Select(popup =>
{
popup
.ViewModel?
.InvokeViewModelAction<INavigating>(x =>
x.WhenNavigatingTo(navigationParameter)
.Subscribe()
.DisposeWith(compositeDisposable));
return popup;
})
.Select(popup =>
Observable
.FromAsync(() => _popupNavigation.PushAsync(popup, animate))
.Select(_ =>
popup
.ViewModel?
.InvokeViewModelAction<INavigated>(x =>
x.WhenNavigatedTo(navigationParameter)
.Subscribe()
.DisposeWith(compositeDisposable))))
.Switch()
.Do(_ =>
{
AddToStackAndTick(PopupSubject, viewModel, false);
Logger.Debug($"Added page '{viewModel.Id}' (contract '{contract}') to stack.");
})
.Select(_ => Unit.Default)
.Subscribe(observer)
.DisposeWith(compositeDisposable);
return Disposable.Create(() => compositeDisposable.Dispose());
});
public async virtual Task CallNavigatingToAsync(INavigatingAware vm, INavigationParameter parameter, NavigationModes mode)
{
this.LogInfo();
if (vm == null)
{
return;
}
await vm.OnNavigatingToAsync(parameter, mode);
}
private async Task Initialize(object ctrl, INavigationParameter parameter)
{
if (ctrl is Control c)
{
if (c.DataContext is INavigationAware aware)
{
aware.Initialize(parameter);
}
if (c.DataContext is INavigationAwareAsync awareAsync)
{
await awareAsync.InitializeAsync(parameter).ConfigureAwait(false);
}
}
}
/// <inheritdoc />
public IObservable <Unit> PopPage(INavigationParameter parameter, bool animate = true)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
var topPage = TopPage().FirstOrDefaultAsync().Wait();
return(View
.PopPage(animate)
.Do(_ =>
{
if (topPage is INavigable navigable)
{
navigable
.WhenNavigatedFrom(parameter)
.ObserveOn(View.MainThreadScheduler)
.Subscribe(navigated =>
Logger.Debug($"Called `WhenNavigatedFrom` on '{navigable.Id}' passing parameter {parameter}"));
}
}));
}
/// <inheritdoc/> public IObservable <Unit> WhenNavigatingTo(INavigationParameter parameter) => Observable.Return(Unit.Default);
/// <inheritdoc/> public virtual IObservable <Unit> WhenNavigatedTo(INavigationParameter parameter) => Observable.Return(Unit.Default);
public virtual IObservable <Unit> WhenNavigatedFrom(INavigationParameter parameter)
{
Disposable.Dispose();
return(Observable.Return(Unit.Default));
}
private void ExecuteNavigation(INavigationParameter parameter) => NavigationExecuter.Execute(parameter, DefaultNavigationCallback);
protected override IObservable <Unit> WhenNavigatingTo(INavigationParameter parameter) => Observable .Create <Unit>(_ =>
public static string GetNo(this INavigationParameter parameter) => parameter.GetValue <string>(No);
public static ViewId GetNextViewId(this INavigationParameter parameter) => parameter.GetValue <ViewId>(NextViewId);
IObservable <Unit> INavigating.WhenNavigatingTo(INavigationParameter parameter) => WhenNavigatingTo(parameter);
IObservable <Unit> INavigated.WhenNavigatedFrom(INavigationParameter parameter) => WhenNavigatedFrom(parameter);
protected virtual IObservable <Unit> WhenNavigatingTo(INavigationParameter parameter) => Observable.Empty <Unit>();
private static T For <T>(this T @this, INavigationParameter navigationParameter) where T : INotificationInfo
{
@this.NavigationParameter = navigationParameter;
return(@this);
}
/// <inheritdoc />
public IObservable <Unit> PushPage(
INavigable navigableViewModel,
INavigationParameter parameter,
string?contract = null,
bool resetStack = false,
bool animate = true) => Observable.Create <Unit>(observer =>
/// <inheritdoc/> public virtual IObservable <Unit> WhenNavigatingTo(INavigationParameter parameter) => Observable.Return(Unit.Default).Do(_ => _navigatingTo.OnNext(Unit.Default));
private async Task <bool> InternalNavigateAsync(Type page, INavigationParameter parameter, NavigationModes mode, Func <bool> navigate)
{
this.LogInfo($"page: {page} parameter: {parameter} mode: {mode}");
// if the identical page+parameter, then don't go
if ((page?.FullName == CurrentPage?.GetType().FullName) && (parameter?.Equals(CurrentParameter) ?? false))
{
return(false);
}
// test parameter
if (!parameter.GetType().GetTypeInfo().IsValueType)
{
throw new Exception("Page parameter is not a Value type. Only value types are supported.");
}
// if confirmation required, then ask
var confirmNavigate = CurrentViewModel as IConfirmNavigation;
if (confirmNavigate != null && !await confirmNavigate.CanNavigateAsync())
{
return(false);
}
// call OnNavigatingFrom()
var oldViewModel = CurrentViewModel;
await NavigatingLogic.CallNavigatingFromAsync(oldViewModel as INavigatingAware);
// call onNavigatingTo() if developer-supported
var newViewModel = ViewModelLogic.ResolveViewModel(page);
await NavigatedLogic.CallNavigatedToAsync(newViewModel as INavigatedAware, parameter, mode);
// navigate
Navigating?.Invoke(this, page);
if (navigate.Invoke())
{
CurrentNavigationMode = mode;
Navigated?.Invoke(this, EventArgs.Empty);
}
else
{
this.LogError($"Navigation failed.");
return(false);
}
// call OnNavigatedFrom()
await NavigatedLogic.CallNavigatedFromAsync(oldViewModel as INavigationAware);
// setup or accept view-model
if (CurrentViewModel == null)
{
if (newViewModel == null)
{
CurrentPage.DataContext = ViewModelLogic.ResolveViewModel(CurrentPage);
}
else
{
CurrentPage.DataContext = newViewModel;
}
}
// call OnNavigatedTo()
newViewModel = newViewModel ?? ViewModelLogic.ResolveViewModel(page);
await NavigatedLogic.CallNavigatedToAsync(newViewModel as INavigatedAware, parameter, mode);
return(true);
}
/// <inheritdoc/> public IObservable <Unit> WhenNavigatedFrom(INavigationParameter parameter) => Observable.Return(Unit.Default).Do(_ => _navigatedFrom.OnNext(Unit.Default));
