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