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()); });
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));