void setupRx() { NavigateBack = new ReactiveCommand( NavigationStack.CountChanged.StartWith(_NavigationStack.Count).Select(x => x > 1)); NavigateBack.Subscribe(_ => NavigationStack.RemoveAt(NavigationStack.Count - 1)); Navigate = new NavigationReactiveCommand(); Navigate.Subscribe(x => { var vm = x as IRoutableViewModel; if (vm == null) { throw new Exception("Navigate must be called on an IRoutableViewModel"); } NavigationStack.Add(vm); }); NavigateAndReset = new NavigationReactiveCommand(); NavigateAndReset.Subscribe(x => { NavigationStack.Clear(); Navigate.Execute(x); }); CurrentViewModel = Observable.Concat( Observable.Defer(() => Observable.Return(NavigationStack.LastOrDefault())), NavigationStack.Changed.Select(_ => NavigationStack.LastOrDefault())); }
public BaseWinController(IBaseWindowView view) : base(view) { fContext = new BaseContext(view); fChangedRecords = new List <GDMRecord>(); fNavman = new NavigationStack <GDMRecord>(); fTabParts = new TabParts[(int)GDMRecordType.rtLast + 1]; }
void setupRx() { if (rxObjectsSetup) { return; } NavigateBack = new ReactiveCommand( NavigationStack.CollectionCountChanged.StartWith(_NavigationStack.Count).Select(x => x > 0)); NavigateBack.Subscribe(_ => NavigationStack.RemoveAt(NavigationStack.Count - 1)); Navigate = new NavigationReactiveCommand(); Navigate.Subscribe(x => { var vm = x as IRoutableViewModel; if (vm == null) { throw new Exception("Navigate must be called on an IRoutableViewModel"); } NavigationStack.Add(vm); }); NavigateAndReset = new NavigationReactiveCommand(); NavigateAndReset.Subscribe(x => { NavigationStack.Clear(); Navigate.Execute(x); }); rxObjectsSetup = true; }
void setupRx() { var countAsBehavior = Observable.Concat( Observable.Defer(() => Observable.Return(_NavigationStack.Count)), NavigationStack.CountChanged); NavigateBack = ReactiveCommand.CreateAsyncObservable( countAsBehavior.Select(x => x > 1), _ => Observable.Return(Unit.Default)); NavigateBack.Subscribe(_ => NavigationStack.RemoveAt(NavigationStack.Count - 1)); Navigate = new ReactiveCommand <object>(Observable.Return(true), x => Observable.Return(x)); Navigate.Subscribe(x => { var vm = x as IRoutableViewModel; if (vm == null) { throw new Exception("Navigate must be called on an IRoutableViewModel"); } NavigationStack.Add(vm); }); NavigateAndReset = new ReactiveCommand <object>(Observable.Return(true), x => Observable.Return(x)); NavigateAndReset .SelectMany(x => { NavigationStack.Clear(); return(Navigate.ExecuteAsync(x)); }).Subscribe(); CurrentViewModel = Observable.Concat( Observable.Defer(() => Observable.Return(NavigationStack.LastOrDefault())), NavigationStack.Changed.Select(_ => NavigationStack.LastOrDefault())); }
/// <summary> /// Pushes the specified navigable to the top of the stack. /// </summary> /// <param name="navigable">The navigable to push to the top ofthe stack</param> public void Push(INavigable navigable) { if (!NavigationStack.ToList().Any(nav => nav.NavigableID == navigable.NavigableID)) { NavigationStack.Push(navigable); } }
public static void PopViewModel() { if (NavigationStack.Any()) { CurrentViewModel.CurrentView = NavigationStack.Pop(); } }
public void NavigateToMasterDetailPage() { //Arrange var app = new MockApp(); var masterPage = new PageContainer() { IsNavigationPage = true, Parameter = "Master Page", ViewModel = LocatorService.Instance.Resolve <HomeViewModel>() }; var detailPage = new PageContainer() { IsNavigationPage = true, Parameter = "Detail Page", ViewModel = LocatorService.Instance.Resolve <HomeViewModel>() };; var navigationService = LocatorService.Instance.Resolve <INavigationService>(); //Act MockApp.SetHomePage <HomeViewModel>(); var pushMasterDetailsTask = navigationService.NavigateToMasterDetailsAsync(masterPage, detailPage); var isMasterDetailExists = ModalStack.Any(x => x.GetType() == typeof(MasterDetailPage)) || NavigationStack.Any(x => x.GetType() == typeof(MasterDetailPage)); //Assert Assert.IsTrue(pushMasterDetailsTask.IsCompleted); Assert.IsTrue(isMasterDetailExists); }
private async Task RoomSelected() { IsListVisible = false; IsIndicatorVisible = true; RoomPayloadModel roomPayload = new RoomPayloadModel() { HotelCode = Settings.HotelCode, ReservationID = Constants.SelectedReservationHeader.ReservationID, RoomNumber = SelectedRoom.RoomNumber }; var responce = await PostAPIservice.AssignRoom(roomPayload); if (responce == "success") { Constants.SelectedReservationHeader.RoomNumber = roomPayload.RoomNumber; Constants.SelectedReservationHeader.RoomIndicatorImgPath = SelectedRoom.RoomStatus == "CLEAN" ? "Icons/CleanRoom.png" : SelectedRoom.RoomStatus == "INSPECTED" ? "Icons/InspectedRoom.png" : "Icons/DirtyRoom.png"; Constants.SelectedReservationDetailSet.RoomNumber = roomPayload.RoomNumber; Constants.SelectedReservationDetailSet.RoomStatus = SelectedRoom.RoomStatus; Constants.SelectedReservationDetailSet.RoomStatusColor = SelectedRoom.RoomStatus == "CLEAN" ? "Green" : SelectedRoom.RoomStatus == "INSPECTED" ? "Orange" : "Red"; MessagingCenter.Send <RoomListViewModel>(this, "RoomDetailsChanged"); await Application.Current.MainPage.DisplayAlert("Success!", "Room has been assigned successfully.", "OK"); await NavigationStack.PopAsync(); } IsListVisible = true; IsIndicatorVisible = false; }
private async Task <StringBuilder> GetLitresBookShelfDataAsync() { try { if (string.IsNullOrEmpty(CatalogModel.AuthorizationString)) { throw new CatalogAuthorizationException(CatalogType.Litres, LitresApiConstants.AUTHORIZATION_URL); } var authorizationString = EncryptService.Decrypt(CatalogModel.AuthorizationString); var postParams = CreatePostParamsForBookShelf(authorizationString); var response = await WebClient.DoPostAsync(LitresApiConstants.BOOK_SHELF_URL, postParams); var stream = await response.Content.ReadAsStreamAsync(); using (var reader = new StreamReader(stream)) { return(new StringBuilder(reader.ReadToEnd())); } } catch (WebException) { if (NavigationStack.Any()) { NavigationStack.Pop(); } throw new ReadCatalogException("Unable read Litres catalog"); } }
void Initialize() { View.SetDefaultGrabTouchAfterLeave(true); Window.Instance.KeyEvent += OnKeyEvent; Stack = new NavigationStack { BackgroundColor = Color.White }; Window.Instance.GetDefaultLayer().Add(Stack); Window.Instance.AddAvailableOrientation(Window.WindowOrientation.Landscape); Window.Instance.AddAvailableOrientation(Window.WindowOrientation.LandscapeInverse); Window.Instance.AddAvailableOrientation(Window.WindowOrientation.Portrait); Window.Instance.AddAvailableOrientation(Window.WindowOrientation.PortraitInverse); Console.WriteLine($"-----------------------------------------------"); Console.WriteLine($"-- DPI : {Window.Instance.Dpi.X}, {Window.Instance.Dpi.Y}"); Console.WriteLine($"-- Orientation : {Window.Instance.GetCurrentOrientation()}"); Console.WriteLine($"-----------------------------------------------"); Window.Instance.Resized += (s, e) => { Console.WriteLine($"---------- Window Resized --------------------"); Console.WriteLine($"-- Orientation : {Window.Instance.GetCurrentOrientation()}"); }; PerformanceMonitor.Attach(); }
public override void Execute(Activity activity) { if (activity is AppCompatActivity appCompatActivity) { NavigationStack <TViewModel> .UpdateFragments(HostStack.NavigationStack, appCompatActivity, FragmentStacksToPop, FragmentStacksToPush, activity as IFragmentActivity); } }
private async void GoBack() { if (_frame.CanGoBack) { if (NavigationStack != null && NavigationStack.Count >= 2) { //pop current view NavigationStack.Pop(); //peek previous view CurrentView = NavigationStack.Peek(); _appState.SessionState.NavigationStack = NavigationStack; } else { CurrentView = ViewType.StartPage; } await Navigate(); } else { OnCanGoBackNavigating(false); } _appState.SessionState.NavigationState = _frame.GetNavigationState(); }
void setupRx() { NavigateBack = new ReactiveCommand( NavigationStack.CollectionCountChanged.StartWith(_NavigationStack.Count).Select(x => x > 0)); NavigateBack.Subscribe(_ => NavigationStack.RemoveAt(NavigationStack.Count - 1)); NavigateForward = new ReactiveCommand(); NavigateForward.Subscribe(x => NavigationStack.Insert(NavigationStack.Count, (IRoutableViewModel)x)); Navigate = new ReactiveCommand(); Navigate.Subscribe(x => { NavigationStack.Clear(); NavigationStack.Add((IRoutableViewModel)x); }); /* * if (_AutoSaveContract != null) { * Observable.Merge(Navigate, NavigateForward, NavigateBack) * .Subscribe(_ => RxStorage.Engine.CreateSyncPoint(this, _AutoSaveContract)); * } */ CurrentViewModel = NavigationStack.CollectionCountChanged .Select(_ => NavigationStack.LastOrDefault()) .Multicast(new ReplaySubject <IRoutableViewModel>(1)).PermaRef(); }
public async Task PopAsync() { if (NavigationStack.Count > 0) { NavigationStack.Pop(); } }
/// <summary> /// Asynchronously dismisses the most recent modally presented <see cref="T:Xamarin.Forms.Page" />, with optional animation. /// </summary> /// <param name="animated">Idicanted if the navigation should be animated.</param> /// <returns>A page object</returns> public async Task <Page> PopModalAsync(bool animated) { var page = await NativeNavigation.PopModalAsync(animated); await RaiseOnNavigateFromAsync(NavigationStack.First(), page, page?.BindingContext); return(page); }
/// <summary> /// Asynchronously removes the most recent <see cref="T:Xamarin.Forms.Page" /> from the navigation stack. /// </summary> /// <returns>The <see cref="T:Xamarin.Forms.Page" /> that had been at the top of the navigation stack.</returns> /// <remarks>To be added.</remarks> public async Task <Page> PopAsync() { var page = await NativeNavigation.PopAsync(); await RaiseOnNavigateFromAsync(NavigationStack.First(), page, page.BindingContext); return(page); }
public static void NavigateTo(ContentControl newView) { if (CurrentViewModel.CurrentView != null) { NavigationStack.Push(CurrentViewModel.CurrentView); } CurrentViewModel.CurrentView = newView; }
public Page NavigateBack() { if (NavigationStack.Count > 0) { NavigationStack.Pop(); } return(CurrentPage()); }
public void Dispose() { foreach (T form in NavigationStack) { form.Dispose(); } MdiChildFormPopCallbacks.Clear(); NavigationStack.Clear(); }
public void GoForward_ThrowsException_IfNoPagesInForwardStack <T>(T item) { var stack = new NavigationStack <T>(); stack.NavigateTo(item); var e = Assert.Throws <InvalidOperationException>(() => stack.GoForward()); Assert.Equal("You cannot navigate forwards as the forward stack is empty.", e.Message); }
private void PushInternal(T form, EventHandler <JcwEventArgs <T> > popCallback) { NavigationStack.Push(form); if (popCallback != null) { MdiChildFormPopCallbacks.Add(form, popCallback); } DisplayForm(form); }
public string GetNavigableId <T>() { foreach (BaseNavigablePage item in NavigationStack.ToList()) { if (item is T) { return(item.NavigableID); } } return(null); }
/// <inheritdoc cref="LoadCommand"/> public void Load() { IsBusy = true; ViewModels.Clear(); NavigationStack.Clear(); var root = CreateNavigationItem(_vmManager.RootViewModel); SetAsCurrentVM(root.ViewModelInfo); IsBusy = false; }
public Page CurrentPage() { if (NavigationStack.Count > 0) { return(NavigationStack.Peek()); } else { return(Page); } }
public void GoBack_ThrowsException_IfNoPagesInBackStack_AllowsEmptyStack <T>(T item) { var stack = new NavigationStack <T>(); stack.NavigateTo(item); stack.GoBack(); var e = Assert.Throws <InvalidOperationException>(() => stack.GoBack()); Assert.Equal("You cannot navigate backwards as the back stack is empty.", e.Message); }
public void GoBackTo_ThrowsException_IfPageNotInBackStack <T>(T item1, T item2, T item3) { var stack = new NavigationStack <T>(); stack.NavigateTo(item1); stack.NavigateTo(item2); var e = Assert.Throws <InvalidOperationException>(() => stack.GoBackTo(item3)); Assert.Equal($"The specified page '{item3}' does not exist in the navigation stack.", e.Message); }
public void GetEnumerator_Generic_EnumeratesPagesInStack <T>(T item1, T item2) { var stack = new NavigationStack <T>(); stack.NavigateTo(item1); stack.NavigateTo(item2); T[] items = ((IEnumerable <T>)stack).ToArray(); Assert.Equal(new T[] { item1, item2 }, items); }
public void GoBack_ThrowsException_IfNoPagesInBackStack_RequiresFirstItem <T>(T item1, T item2) { var stack = new NavigationStack <T>(NavigationStackType.RequireFirstItem); stack.NavigateTo(item1); stack.NavigateTo(item2); stack.GoBack(); var e = Assert.Throws <InvalidOperationException>(() => stack.GoBack()); Assert.Equal("You cannot navigate backwards as the back stack is empty.", e.Message); }
public void InitialStack_IsEmpty_RequiresFirstItem <T>(T defaultItem) { var stack = new NavigationStack <T>(NavigationStackType.RequireFirstItem); Assert.NotNull(stack); Assert.Equal(0, stack.Count); Assert.Equal(1, stack.MinimumCount); Assert.Equal(default(T), stack.CurrentItem); Assert.False(stack.CanGoBack); Assert.False(stack.CanGoForward); }
//___________________________________________________________________________________________________ #region Static Methods private static UINavigationController NavigationControllerWithIdentifier(string identifier, UIViewController destination) { // Try to get opened navigation controller if (!NavigationStack.ContainsKey(identifier)) { // Instantiate new navigation controller UINavigationController nav = new UINavigationController(destination); // Add navigation controller to stack NavigationStack.Add(identifier, nav); } // Return navigation controller from stack return(NavigationStack [identifier]); }