public override void OnNavigatedTo(Prism.Navigation.NavigationParameters parameters) { base.OnNavigatedTo(parameters); mText = parameters.GetValue <string>("text"); Debug.WriteLine(mText); }
public async Task NavedFromAsync(object viewmodel, NavigationMode mode, Page sourcePage, Type sourceType, object sourceParameter, Page targetPage, Type targetType, object targetParameter, bool suspending) { Services.NavigationService.NavigationService.DebugWrite(); if (sourcePage == null) { return; } else if (viewmodel == null) { return; } else if (viewmodel is Classic.INavigatedAwareAsync) { var vm = viewmodel as Classic.INavigatedAwareAsync; await vm?.OnNavigatedFromAsync(PageState(sourcePage), suspending); } else if (viewmodel is Portable.INavigatedAware) { var vm = viewmodel as Portable.INavigatedAware; var parameters = new Portable.NavigationParameters(); vm?.OnNavigatedFrom(parameters); } else if (viewmodel is Portable.INavigatedAwareAsync) { var vm = viewmodel as Portable.INavigatedAwareAsync; var parameters = new Portable.NavigationParameters(); await vm?.OnNavigatedFromAsync(parameters); } }
public override void OnNavigatingTo(Prism.Navigation.NavigationParameters parameters) { _ea.GetEvent <InitializeTabbedChildrenEvent>().Publish(parameters); /*if (parameters.ContainsKey("parametro")) * this.Titulo = parameters["parametro"].ToString();*/ }
public override void OnNavigatingTo(Prism.Navigation.NavigationParameters parameters) { if (parameters.ContainsKey("Order")) { Order = parameters["Order"] as Order; SetViewFields(); } }
private async Task infoUserCommand() { var navParameters = new Prism.Navigation.NavigationParameters(); navParameters.Add("UserName", UserName); await _navigationService.NavigateAsync($"/CustomMasterDetailPage/NavigationPage/InfoOfUserMyView", navParameters); }
void SelectedItem(Item item) { var navParameters = new Prism.Navigation.NavigationParameters { { "selecttedItem", item } }; Navigate("DetailItemPage", navParameters); }
//private void CompletedTaskShow() //{ // if (ShowCompletedTask) // { // //var items = new ObservableCollection<Item>(); // foreach (var item in Items) // { // if (item.Completed) // CompletedItems.Add(item); // } // //if(items.Count > 0) // // CompletedItems = new ObservableCollection<Item>(items); // } // else // { // CompletedItems.Clear(); // } // ShowCompletedTask = !ShowCompletedTask; //} void EditItem(Item item) { var navParameters = new Prism.Navigation.NavigationParameters { { "selecttedItem", item } }; Navigate("AddPage", navParameters); }
private void MyClickButton() { var par = new Prism.Navigation.NavigationParameters(); par.Add("hell", 4); _navigationService.NavigateAsync("SecondPage", par); //pageDialogService.DisplayActionSheetAsync("hello", "hi", "ok"); }
public async Task <bool> NavingFromCancelsAsync(object viewmodel, NavigationMode mode, Page sourcePage, Type sourceType, object sourceParameter, Page targetPage, Type targetType, object targetParameter, bool suspending) { Services.NavigationService.NavigationService.DebugWrite(); if (sourcePage == null) { return(false); } else if (viewmodel == null) { return(false); } else if (viewmodel is Classic.INavigatingAwareAsync) { var deferral = new DeferralManager(); var navigatingEventArgs = new Classic.NavigatingEventArgs(deferral) { Page = sourcePage, PageType = sourcePage?.GetType(), Parameter = sourceParameter, NavigationMode = mode, TargetPageType = targetType, TargetPageParameter = targetParameter, Suspending = suspending, }; try { var vm = viewmodel as Classic.INavigatingAwareAsync; await vm?.OnNavigatingFromAsync(navigatingEventArgs); await deferral.WaitForDeferralsAsync(); } catch { Debugger.Break(); } return(navigatingEventArgs.Cancel); } else if (viewmodel is Portable.IConfirmNavigationAsync) { var parameters = new Portable.NavigationParameters(); parameters.Add("NavigationMode", mode.ToPrismNavigationMode()); parameters.Add("SourceType", sourceType); parameters.Add("SourceParameter", sourceParameter); parameters.Add("TargetType", targetType); parameters.Add("TargetParameter", targetParameter); parameters.Add("Suspending", suspending); var vm = viewmodel as Portable.IConfirmNavigationAsync; return(!await vm?.CanNavigateAsync(parameters)); } else { return(true); } }
private async Task onlogin() { var navParameters = new Prism.Navigation.NavigationParameters(); navParameters.Add("UserName", UserName); await _navigationService.NavigateAsync( $"/CustomMasterDetailPage/NavigationPage/MainPageView", navParameters ); }
public void OnNavigatedTo_ShouldCallContainsFromShoppingCartService() { INavigationParameters navigationParameters = new Prism.Navigation.NavigationParameters(); Dog dog = _dogList[0]; navigationParameters.Add("selectedDogData", dog); _dogDetailViewModel.OnNavigatedTo(navigationParameters); _mockShoppingCartService.Verify(x => x.Contains(It.IsAny <int>()), Times.Once()); _mockShoppingCartService.VerifyNoOtherCalls(); }
public void DogAlreadyInTheShoppingCart_OnNavigatedTo_ShouldChangeCanExecuteToFalse() { _mockShoppingCartService.Setup(r => r.Contains(It.IsAny <int>())).Returns(true); _mockAuthenticationService.Setup(r => r.IsUserAuthenticated).Returns(true); _dogDetailViewModel = new DogDetailViewModel(_mockNavigationService.Object, _mockShoppingCartService.Object, _mockAuthenticationService.Object); INavigationParameters navigationParameters = new Prism.Navigation.NavigationParameters(); _dogDetailViewModel.SelectedDog = _dogList[0]; _dogDetailViewModel.OnNavigatedTo(navigationParameters); _dogDetailViewModel.AddSelectedDogToTheShoppingCart.CanExecute(null).Should().BeFalse(); }
private async void Navega() { if (Selection != null) { // await PageDialogService.DisplayAlertAsync("app", Selection.nome, "Ok"); var navigationParams = new Prism.Navigation.NavigationParameters(); navigationParams.Add("paciente", Selection); //var mainPage = $"{nameof(NavigationPage)}/{nameof(Exames)}"; await NavigationService.NavigateAsync("Exames", navigationParams); Selection = null; } }
/// <summary> /// Ons the navigated to. /// </summary> /// <param name="parameters">Parameters.</param> public override void OnNavigatedTo(Prism.Navigation.NavigationParameters parameters) { this.Properties = parameters.GetValue <PropertyViewModel>(MagicStrings.Lease); this.ExecuteAsyncTask(async() => { await Task.WhenAll(new Task[] { this.LoadAccountStatement(), this.LoadCurrentBalance(), }); }).Forget(); base.OnNavigatedTo(parameters); }
public async Task NavedToAsync(object viewmodel, NavigationMode mode, Page sourcePage, Type sourceType, object sourceParameter, Page targetPage, Type targetType, object targetParameter) { Services.NavigationService.NavigationService.DebugWrite(); if (targetPage == null) { throw new ArgumentNullException(nameof(targetPage)); } if (mode == NavigationMode.New) { PageState(targetPage).Clear(); } if (viewmodel == null) { return; } else if (viewmodel is Classic.INavigatedAwareAsync) { var vm = viewmodel as Classic.INavigatedAwareAsync; await vm?.OnNavigatedToAsync(targetParameter, mode, PageState(targetPage)); } else if (viewmodel is Portable.INavigatedAware) { var parameters = new Portable.NavigationParameters(); parameters.Add("NavigationMode", mode.ToPrismNavigationMode()); parameters.Add("SourceType", sourceType); parameters.Add("SourceParameter", sourceParameter); parameters.Add("TargetType", targetType); parameters.Add("TargetParameter", targetParameter); var vm = viewmodel as Portable.INavigatedAware; vm?.OnNavigatedTo(parameters); } else if (viewmodel is Portable.INavigatedAwareAsync) { var parameters = new Portable.NavigationParameters(); parameters.Add("NavigationMode", mode.ToPrismNavigationMode()); parameters.Add("SourceType", sourceType); parameters.Add("SourceParameter", sourceParameter); parameters.Add("TargetType", targetType); parameters.Add("TargetParameter", targetParameter); var vm = viewmodel as Portable.INavigatedAwareAsync; await vm?.OnNavigatedToAsync(parameters); } targetPage.InitializeBindings(); targetPage.UpdateBindings(); }
public void OnNavigatedTo_SelectedDogInformations_ShouldBeDisplayed() { INavigationParameters navigationParameters = new Prism.Navigation.NavigationParameters(); Dog dog = _dogList[0]; navigationParameters.Add("selectedDogData", dog); _dogDetailViewModel.OnNavigatedTo(navigationParameters); _dogDetailViewModel.SelectedDog.Should().BeEquivalentTo(dog); _dogDetailViewModel.SelectedDog.Description.Should().BeEquivalentTo(dog.Description); _dogDetailViewModel.SelectedDog.Price.Should().Be(dog.Price); _dogDetailViewModel.SelectedDog.Race.Should().BeEquivalentTo(dog.Race); _dogDetailViewModel.SelectedDog.Sex.Should().BeEquivalentTo(dog.Sex); }
public void UserIsNotAuthenticated_OnNavigatedTo_ShouldChangeAddSelectedDogToTheShoppingCartCanExecuteToFalse() { _dogDetailViewModel.SelectedDog = _fixture.CreateFakeDog().Generate(); _dogDetailViewModel.SelectedDog.Id = 1; _mockShoppingCartService.Setup(r => r.Contains(It.IsAny <int>())).Returns(false); _mockAuthenticationService.Setup(r => r.IsUserAuthenticated).Returns(false); // <------ var user = _fixture.CreateFakeUser(5).Generate(); _mockAuthenticationService.Setup(r => r.AuthenticatedUser).Returns(user); INavigationParameters navigationParameters = new Prism.Navigation.NavigationParameters(); _dogDetailViewModel.OnNavigatedTo(navigationParameters); _dogDetailViewModel.AddSelectedDogToTheShoppingCart.CanExecute(null).Should().BeFalse(); }
public override void OnNavigatedTo(Prism.Navigation.NavigationParameters parameters) { todoRepository.GetQueryable() .SubscribeForNotifications(UpdateTodos); }
protected virtual async Task ProcessNavigationForMasterDetailPage(MasterDetailPage currentPage, string nextSegment, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated) { bool isPresented = GetMasterDetailPageIsPresented(currentPage); var detail = currentPage.Detail; if (detail == null) { var newDetail = CreatePageFromSegment(nextSegment); await ProcessNavigation(newDetail, segments, parameters, useModalNavigation, animated); await DoNavigateAction(null, nextSegment, newDetail, parameters, onNavigationActionCompleted : () => { currentPage.IsPresented = isPresented; currentPage.Detail = newDetail; }); return; } if (useModalNavigation.HasValue && useModalNavigation.Value) { var nextPage = CreatePageFromSegment(nextSegment); await ProcessNavigation(nextPage, segments, parameters, useModalNavigation, animated); await DoNavigateAction(currentPage, nextSegment, nextPage, parameters, async() => { currentPage.IsPresented = isPresented; await DoPush(currentPage, nextPage, true, animated); }); return; } var nextSegmentType = PageNavigationRegistry.GetPageType(UriParsingHelper.GetSegmentName(nextSegment)); if (detail.GetType() == nextSegmentType) { await ProcessNavigation(detail, segments, parameters, useModalNavigation, animated); await DoNavigateAction(null, nextSegment, detail, parameters, onNavigationActionCompleted : () => { currentPage.IsPresented = isPresented; }); return; } else { var newDetail = CreatePageFromSegment(nextSegment); await ProcessNavigation(newDetail, segments, parameters, newDetail is NavigationPage?false : true, animated); await DoNavigateAction(detail, nextSegment, newDetail, parameters, onNavigationActionCompleted : () => { currentPage.IsPresented = isPresented; currentPage.Detail = newDetail; PageUtilities.DestroyPage(detail); }); return; } }
protected virtual async Task ProcessNavigation(Page currentPage, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated) { if (segments.Count == 0) { return; } var nextSegment = segments.Dequeue(); if (nextSegment == RemovePageSegment) { await ProcessNavigationForRemovePageSegments(currentPage, nextSegment, segments, parameters, useModalNavigation, animated); return; } if (currentPage == null) { await ProcessNavigationForRootPage(nextSegment, segments, parameters, useModalNavigation, animated); return; } if (currentPage is ContentPage) { await ProcessNavigationForContentPage(currentPage, nextSegment, segments, parameters, useModalNavigation, animated); } else if (currentPage is NavigationPage) { await ProcessNavigationForNavigationPage((NavigationPage)currentPage, nextSegment, segments, parameters, useModalNavigation, animated); } else if (currentPage is TabbedPage) { await ProcessNavigationForTabbedPage((TabbedPage)currentPage, nextSegment, segments, parameters, useModalNavigation, animated); } else if (currentPage is CarouselPage) { await ProcessNavigationForCarouselPage((CarouselPage)currentPage, nextSegment, segments, parameters, useModalNavigation, animated); } else if (currentPage is MasterDetailPage) { await ProcessNavigationForMasterDetailPage((MasterDetailPage)currentPage, nextSegment, segments, parameters, useModalNavigation, animated); } }
/// <summary> /// Initiates navigation to the target specified by the <typeparamref name="T"/>. /// </summary> /// <typeparam name="T">The type which will be used to identify the name of the navigation target.</typeparam> /// <param name="parameters">The navigation parameters</param> /// <param name="useModalNavigation">If <c>true</c> uses PopModalAsync, if <c>false</c> uses PopAsync</param> /// <param name="animated">If <c>true</c> the transition is animated, if <c>false</c> there is no animation on transition.</param> public void Navigate <T>(NavigationParameters parameters = null, bool useModalNavigation = true, bool animated = true) { Navigate(typeof(T).FullName, parameters, useModalNavigation, animated); }
protected virtual Task ProcessNavigationForAbsoulteUri(Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated) { return(ProcessNavigation(null, segments, parameters, useModalNavigation, animated)); }
protected virtual async Task ProcessNavigationForRemovePageSegments(Page currentPage, string nextSegment, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated) { if (!HasNavigationPageParent(currentPage)) { throw new InvalidOperationException("Removing views using the relative '../' syntax while navigating is only supported within a NavigationPage"); } List <Page> pagesToRemove = new List <Page>(); pagesToRemove.Add(currentPage); var currentPageIndex = currentPage.Navigation.NavigationStack.Count; if (currentPage.Navigation.NavigationStack.Count > 0) { currentPageIndex = currentPage.Navigation.NavigationStack.Count - 1; } while (segments.Peek() == RemovePageSegment) { currentPageIndex -= 1; pagesToRemove.Add(currentPage.Navigation.NavigationStack[currentPageIndex]); nextSegment = segments.Dequeue(); } await ProcessNavigation(currentPage, segments, parameters, useModalNavigation, animated); var navigationPage = (NavigationPage)currentPage.Parent; foreach (var page in pagesToRemove) { navigationPage.Navigation.RemovePage(page); PageUtilities.DestroyPage(page); } }
protected virtual async Task ProcessNavigationForRootPage(string nextSegment, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated) { var nextPage = CreatePageFromSegment(nextSegment); await ProcessNavigation(nextPage, segments, parameters, useModalNavigation, animated); var currentPage = _applicationProvider.MainPage; var modalStack = currentPage?.Navigation.ModalStack.ToList(); await DoNavigateAction(GetCurrentPage(), nextSegment, nextPage, parameters, async() => { await DoPush(null, nextPage, useModalNavigation, animated); }); if (currentPage != null) { PageUtilities.DestroyWithModalStack(currentPage, modalStack); } }
protected virtual async Task ProcessNavigationForContentPage(Page currentPage, string nextSegment, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated) { var nextPageType = PageNavigationRegistry.GetPageType(UriParsingHelper.GetSegmentName(nextSegment)); bool useReverse = UseReverseNavigation(currentPage, nextPageType); if (!useReverse) { var nextPage = CreatePageFromSegment(nextSegment); await ProcessNavigation(nextPage, segments, parameters, useModalNavigation, animated); await DoNavigateAction(currentPage, nextSegment, nextPage, parameters, async() => { await DoPush(currentPage, nextPage, useModalNavigation, animated); }); } else { await UseReverseNavigation(currentPage, nextSegment, segments, parameters, useModalNavigation, animated); } }
public async Task<bool> NavingFromCancelsAsync(object viewmodel, NavigationMode mode, Page sourcePage, Type sourceType, object sourceParameter, Page targetPage, Type targetType, object targetParameter, bool suspending) { Services.NavigationService.NavigationService.DebugWrite(); if (sourcePage == null) { return false; } else if (viewmodel == null) { return false; } else if (viewmodel is Classic.INavigatingAwareAsync) { var deferral = new DeferralManager(); var navigatingEventArgs = new Classic.NavigatingEventArgs(deferral) { Page = sourcePage, PageType = sourcePage?.GetType(), Parameter = sourceParameter, NavigationMode = mode, TargetPageType = targetType, TargetPageParameter = targetParameter, Suspending = suspending, }; try { var vm = viewmodel as Classic.INavigatingAwareAsync; await vm?.OnNavigatingFromAsync(navigatingEventArgs); await deferral.WaitForDeferralsAsync(); } catch { Debugger.Break(); } return navigatingEventArgs.Cancel; } else if (viewmodel is Portable.IConfirmNavigationAsync) { var parameters = new Portable.NavigationParameters(); parameters.Add("NavigationMode", mode.ToPrismNavigationMode()); parameters.Add("SourceType", sourceType); parameters.Add("SourceParameter", sourceParameter); parameters.Add("TargetType", targetType); parameters.Add("TargetParameter", targetParameter); parameters.Add("Suspending", suspending); var vm = viewmodel as Portable.IConfirmNavigationAsync; return !await vm?.CanNavigateAsync(parameters); } else { return true; } }
public override void OnNavigatingTo(Prism.Navigation.NavigationParameters parameters) { System.Diagnostics.Debug.WriteLine($"{Title} OnNavigatingTo"); _ea.GetEvent <InitializeTabbedChildrenEvent>().Publish(parameters); }
protected virtual async Task ProcessNavigationForNavigationPage(NavigationPage currentPage, string nextSegment, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated) { if (currentPage.Navigation.NavigationStack.Count == 0) { await UseReverseNavigation(currentPage, nextSegment, segments, parameters, false, animated); return; } var clearNavigationStack = GetClearNavigationPageNavigationStack(currentPage); var isEmptyOfNavigationStack = currentPage.Navigation.NavigationStack.Count == 0; List <Page> destroyPages; if (clearNavigationStack && !isEmptyOfNavigationStack) { destroyPages = currentPage.Navigation.NavigationStack.ToList(); destroyPages.Reverse(); await currentPage.Navigation.PopToRootAsync(false); } else { destroyPages = new List <Page>(); } var topPage = currentPage.Navigation.NavigationStack.LastOrDefault(); var nextPageType = PageNavigationRegistry.GetPageType(UriParsingHelper.GetSegmentName(nextSegment)); if (topPage?.GetType() == nextPageType) { if (clearNavigationStack) { destroyPages.Remove(destroyPages.Last()); } if (segments.Count > 0) { await UseReverseNavigation(topPage, segments.Dequeue(), segments, parameters, false, animated); } await DoNavigateAction(topPage, nextSegment, topPage, parameters); } else { await UseReverseNavigation(currentPage, nextSegment, segments, parameters, false, animated); if (clearNavigationStack && !isEmptyOfNavigationStack) { currentPage.Navigation.RemovePage(topPage); } } foreach (var destroyPage in destroyPages) { PageUtilities.DestroyPage(destroyPage); } }
protected virtual async Task ProcessNavigationForCarouselPage(CarouselPage currentPage, string nextSegment, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated) { var nextPage = CreatePageFromSegment(nextSegment); await ProcessNavigation(nextPage, segments, parameters, useModalNavigation, animated); await DoNavigateAction(currentPage, nextSegment, nextPage, parameters, async() => { await DoPush(currentPage, nextPage, useModalNavigation, animated); }); }
protected static async Task DoNavigateAction(Page fromPage, string toSegment, Page toPage, NavigationParameters parameters, Func <Task> navigationAction = null, Action onNavigationActionCompleted = null) { var segmentParameters = UriParsingHelper.GetSegmentParameters(toSegment, parameters); segmentParameters.Add(KnownNavigationParameters.NavigationMode, NavigationMode.New); var canNavigate = await PageUtilities.CanNavigateAsync(fromPage, segmentParameters); if (!canNavigate) { return; } OnNavigatingTo(toPage, segmentParameters); if (navigationAction != null) { await navigationAction(); } OnNavigatedFrom(fromPage, segmentParameters); onNavigationActionCompleted?.Invoke(); OnNavigatedTo(toPage, segmentParameters); }
protected virtual async Task UseReverseNavigation(Page currentPage, string nextSegment, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated) { var navigationStack = new Stack <string>(); if (!String.IsNullOrWhiteSpace(nextSegment)) { navigationStack.Push(nextSegment); } var illegalSegments = new Queue <string>(); bool illegalPageFound = false; foreach (var item in segments) { //if we run itno an illegal page, we need to create new navigation segments to properly handle the deep link if (illegalPageFound) { illegalSegments.Enqueue(item); continue; } var pageType = PageNavigationRegistry.GetPageType(UriParsingHelper.GetSegmentName(item)); if (IsSameOrSubclassOf <MasterDetailPage>(pageType)) { illegalSegments.Enqueue(item); illegalPageFound = true; } else { navigationStack.Push(item); } } var pageOffset = currentPage.Navigation.NavigationStack.Count; if (currentPage.Navigation.NavigationStack.Count > 2) { pageOffset = currentPage.Navigation.NavigationStack.Count - 1; } bool insertBefore = false; while (navigationStack.Count > 0) { var segment = navigationStack.Pop(); var nextPage = CreatePageFromSegment(segment); await DoNavigateAction(currentPage, segment, nextPage, parameters, async() => { await DoPush(currentPage, nextPage, useModalNavigation, animated, insertBefore, pageOffset); }); insertBefore = true; } //if an illegal page is found, we force a Modal navigation if (illegalSegments.Count > 0) { await ProcessNavigation(currentPage.Navigation.NavigationStack.Last(), illegalSegments, parameters, true, animated); } }