public SelectedItemMainViewModel(IViewModelPresenter presenter, IOperationCallbackManager callbackManager, IToastPresenter toastPresenter) : base(toastPresenter)
{
Should.NotBeNull(presenter, "presenter");
Should.NotBeNull(callbackManager, "callbackManager");
_presenter = presenter;
_callbackManager = callbackManager;
_presenter.DynamicPresenters.Add(this);
}
public MainViewModel(IViewModelPresenter viewModelPresenter)
{
Should.NotBeNull(viewModelPresenter, "viewModelPresenter");
viewModelPresenter.DynamicPresenters.Add(new DynamicMultiViewModelPresenter(this));
OpenProductsCommand = RelayCommandBase.FromAsyncHandler(OpenProducts);
OpenOrdersCommand = RelayCommandBase.FromAsyncHandler(OpenOrders);
}
private bool CanShowViewModel(IViewModel viewModel, IDataContext context,
IViewModelPresenter parentPresenter)
{
bool data;
if (context.TryGetData(NavigationConstants.SuppressPageNavigation, out data) && data)
return false;
if (_canShowViewModel == null)
return CanShowViewModelDefault(viewModel, context, parentPresenter);
return _canShowViewModel(viewModel, context, parentPresenter);
}
/// <summary>
/// Initializes a new instance of the <see cref="ApplicationStateManager" /> class.
/// </summary>
public ApplicationStateManager([NotNull] ISerializer serializer, [NotNull] IViewModelProvider viewModelProvider,
[NotNull] IViewManager viewManager, [NotNull] IViewModelPresenter viewModelPresenter)
{
Should.NotBeNull(serializer, "serializer");
Should.NotBeNull(viewModelProvider, "viewModelProvider");
Should.NotBeNull(viewManager, "viewManager");
Should.NotBeNull(viewModelPresenter, "viewModelPresenter");
_serializer = serializer;
_viewModelProvider = viewModelProvider;
_viewManager = viewManager;
_viewModelPresenter = viewModelPresenter;
}
public MainViewModel(IViewModelPresenter viewModelPresenter, IToastPresenter toastPresenter)
{
Should.NotBeNull(viewModelPresenter, "viewModelPresenter");
Should.NotBeNull(toastPresenter, "toastPresenter");
_viewModelPresenter = viewModelPresenter;
_toastPresenter = toastPresenter;
ShowFirstWindowCommand = RelayCommandBase.FromAsyncHandler(ShowFirstWindow);
ShowSecondWindowCommand = RelayCommandBase.FromAsyncHandler(ShowSecondWindow);
ShowFirstTabCommand = RelayCommandBase.FromAsyncHandler(ShowFirstTab);
ShowSecondTabCommand = RelayCommandBase.FromAsyncHandler(ShowSecondTab);
ShowFirstPageCommand = RelayCommandBase.FromAsyncHandler(ShowFirstPage);
ShowSecondPageCommand = RelayCommandBase.FromAsyncHandler(ShowSecondPage);
ShowBackStackPageCommand = RelayCommandBase.FromAsyncHandler(ShowBackStackPage);
//NOTE The DynamicMultiViewModelPresenter allows to use the current view model as presenter.
_presenter = new DynamicMultiViewModelPresenter(this);
viewModelPresenter.DynamicPresenters.Add(_presenter);
}
public virtual Task <bool> TryCloseAsync(IDataContext context, IViewModelPresenter parentPresenter)
{
return(null);
}
private static bool CanShowViewModelNavigationPresenter(IViewModel viewModel, IDataContext dataContext, IViewModelPresenter arg3)
{
var viewName = viewModel.GetViewName(dataContext);
var container = viewModel.GetIocContainer(true);
var mappingProvider = container.Get<IViewMappingProvider>();
var mappingItem = mappingProvider.FindMappingForViewModel(viewModel.GetType(), viewName, false);
return mappingItem != null && typeof(Page).IsAssignableFrom(mappingItem.ViewType);
}
public virtual INavigationOperation TryShowAsync(IViewModel viewModel, IDataContext context,
IViewModelPresenter parentPresenter)
{
Should.NotBeNull(viewModel, "viewModel");
bool data;
if (context.TryGetData(NavigationConstants.SuppressTabNavigation, out data) && data)
return null;
if (!CanShowViewModel(viewModel, context, parentPresenter))
return null;
MultiViewModel.AddViewModel(viewModel, true);
var operation = new NavigationOperation();
CallbackManager.Register(OperationType.TabNavigation, viewModel, operation.ToOperationCallback(), context);
return operation;
}
private static bool CanShowViewModelTabPresenter(IViewModel viewModel, IDataContext dataContext, IViewModelPresenter arg3)
{
var viewName = viewModel.GetViewName(dataContext);
var container = viewModel.GetIocContainer(true);
var mappingProvider = container.Get<IViewMappingProvider>();
var mappingItem = mappingProvider.FindMappingForViewModel(viewModel.GetType(), viewName, false);
return mappingItem == null || typeof(ITabView).IsAssignableFrom(mappingItem.ViewType) ||
!typeof(UIViewController).IsAssignableFrom(mappingItem.ViewType);
}
public INavigationOperation TryShowAsync(IViewModel viewModel, IDataContext context,
IViewModelPresenter parentPresenter)
{
var viewMediator = TryCreateWindowViewMediator(viewModel, context);
if (viewMediator == null)
return null;
var tcs = new TaskCompletionSource<object>();
var operation = new NavigationOperation(tcs.Task);
if (_currentTask == null)
Show(viewMediator, operation, context, tcs);
else
_currentTask.TryExecuteSynchronously(_ => Show(viewMediator, operation, context, tcs));
return operation;
}
public bool Restore(IViewModel viewModel, IDataContext context, IViewModelPresenter parentPresenter)
{
var view = context.GetData(RestoredViewConstant);
if (view == null)
return false;
var mediator = TryCreateWindowViewMediator(viewModel, context);
if (mediator == null)
return false;
mediator.UpdateView(view, context.GetData(IsOpenViewConstant), context);
return true;
}
IAsyncOperation IDynamicViewModelPresenter.TryShowAsync(IDataContext context, IViewModelPresenter parentPresenter)
{
if (!_isStarted || _hasRootPage)
{
return(null);
}
if (WrapToNavigationController)
{
_hasRootPage = true;
return(parentPresenter.ShowAsync(context));
}
var viewModel = context.GetData(NavigationConstants.ViewModel);
if (viewModel == null)
{
return(null);
}
var mappingItem = IocContainer.Get <IViewMappingProvider>().FindMappingForViewModel(viewModel.GetType(), viewModel.GetViewName(context), false);
if (mappingItem == null || !typeof(UIViewController).IsAssignableFrom(mappingItem.ViewType))
{
return(null);
}
_hasRootPage = true;
viewModel.Settings.State.AddOrUpdate(IsRootConstant, null);
var operation = new AsyncOperation <object>();
IocContainer.Get <IOperationCallbackManager>().Register(OperationType.PageNavigation, viewModel, operation.ToOperationCallback(), context);
ServiceProvider.ThreadManager.Invoke(ExecutionMode.AsynchronousOnUiThread, this, viewModel, context, (@this, vm, ctx) => @this.InitializeRootPage(vm, ctx));
return(operation);
}
INavigationOperation IDynamicViewModelPresenter.TryShowAsync(IViewModel viewModel, IDataContext context, IViewModelPresenter parentPresenter)
{
parentPresenter.DynamicPresenters.Remove(this);
_application.RootVisual = (UIElement)ViewManager.GetOrCreateView(viewModel, null, context);
return new NavigationOperation();
}
INavigationOperation IDynamicViewModelPresenter.TryShowAsync(IViewModel viewModel, IDataContext context, IViewModelPresenter parentPresenter)
{
parentPresenter.DynamicPresenters.Remove(this);
var operation = parentPresenter.ShowAsync(viewModel, context);
if (ShutdownOnMainViewModelClose)
{
operation.ContinueWith(result =>
{
Application application = Application.Current;
if (application != null)
{
Action action = application.Shutdown;
application.Dispatcher.BeginInvoke(action);
}
});
}
if (_rootWindow != null)
{
var iocContainer = MvvmApplication.Current.IocContainer;
IWindowViewMediator mediator = new WindowViewMediator(_rootWindow, viewModel, iocContainer.Get<IThreadManager>(),
iocContainer.Get<IViewManager>(), iocContainer.Get<IWrapperManager>(),
iocContainer.Get<IOperationCallbackManager>());
mediator.UpdateView(new PlatformWrapperRegistrationModule.WindowViewWrapper(_rootWindow), true, context);
_rootWindow.Show();
}
return operation;
}
public INavigationOperation TryShowAsync(IViewModel viewModel, IDataContext context, IViewModelPresenter parentPresenter)
{
if (viewModel == this)
return null;
var operation = new NavigationOperation();
var callback = operation.ToOperationCallback();
//Saving callback to view model state that will allow us to execute it even after app save\restore cycle.
_callbackManager.Register(NavigationType, viewModel, callback, context);
OnShowViewModel(viewModel);
return operation;
}
public BackStackMainViewModel(IViewModelPresenter presenter, IOperationCallbackManager callbackManager, IToastPresenter toastPresenter)
: base(presenter, callbackManager, toastPresenter)
{
_viewModels = new Stack<IViewModel>();
}
INavigationOperation IDynamicViewModelPresenter.TryShowAsync(IViewModel viewModel, IDataContext context, IViewModelPresenter parentPresenter)
{
parentPresenter.DynamicPresenters.Remove(this);
var operation = parentPresenter.ShowAsync(viewModel, context);
if (ShutdownOnMainViewModelClose)
operation.ContinueWith(result => Application.Exit());
if (AutoRunApplication)
Application.Run();
return operation;
}
public virtual INavigationOperation TryShowAsync(IViewModel viewModel, IDataContext context,
IViewModelPresenter parentPresenter)
{
Should.NotBeNull(viewModel, nameof(viewModel));
if (ReferenceEquals(viewModel, _multiViewModel))
return null;
bool data;
if (context.TryGetData(NavigationConstants.SuppressTabNavigation, out data) && data)
return null;
if (!CanShowViewModel(viewModel, context, parentPresenter))
return null;
if (MultiViewModel.ItemsSource.Contains(viewModel))
MultiViewModel.SelectedItem = viewModel;
else
MultiViewModel.AddViewModel(viewModel, true);
var operation = new NavigationOperation();
CallbackManager.Register(OperationType.TabNavigation, viewModel, operation.ToOperationCallback(), context);
return operation;
}
public BackStackMainViewModel(IViewModelPresenter presenter, IOperationCallbackManager callbackManager, IToastPresenter toastPresenter)
: base(presenter, callbackManager, toastPresenter)
{
_viewModels = new Stack <IViewModel>();
}
private static bool CanShowViewModelNavigationPresenter(IViewModel viewModel, IDataContext dataContext, IViewModelPresenter arg3)
{
var viewName = viewModel.GetViewName(dataContext);
var container = viewModel.GetIocContainer(true);
var mappingProvider = container.Get <IViewMappingProvider>();
var mappingItem = mappingProvider.FindMappingForViewModel(viewModel.GetType(), viewName, false);
return(mappingItem != null && typeof(UIViewController).IsAssignableFrom(mappingItem.ViewType));
}
public bool Restore(IViewModel viewModel, IDataContext context, IViewModelPresenter parentPresenter)
{
if (!CanShowViewModel(viewModel, context, parentPresenter))
return false;
INavigationProvider provider;
if (viewModel.GetIocContainer(true).TryGet(out provider))
{
provider.OnNavigated(viewModel, NavigationMode.Reset, context);
return true;
}
return false;
}
INavigationOperation IDynamicViewModelPresenter.TryShowAsync(IViewModel viewModel, IDataContext context, IViewModelPresenter parentPresenter)
{
parentPresenter.DynamicPresenters.Remove(this);
_mainViewModel = viewModel;
var view = (Page)ViewManager.GetOrCreateView(_mainViewModel, true, context);
NavigationPage page = view as NavigationPage;
if (page == null && _wrapToNavigationPage)
page = CreateNavigationPage(view);
if (page != null)
{
var iocContainer = MvvmApplication.Current.IocContainer;
INavigationService navigationService;
if (!iocContainer.TryGet(out navigationService))
{
navigationService = CreateNavigationService();
iocContainer.BindToConstant(navigationService);
}
//Activating navigation provider
INavigationProvider provider;
iocContainer.TryGet(out provider);
navigationService.UpdateRootPage(page);
view = page;
}
Application.Current.MainPage = view;
return new NavigationOperation();
}
public INavigationOperation TryShowAsync(IViewModel viewModel, IDataContext context,
IViewModelPresenter parentPresenter)
{
if (!CanShowViewModel(viewModel, context, parentPresenter))
return null;
var tcs = new TaskCompletionSource<object>();
var operation = new NavigationOperation(tcs.Task);
context = context.ToNonReadOnly();
context.AddOrUpdate(NavigationConstants.ViewModel, viewModel);
var provider = viewModel.GetIocContainer(true).Get<INavigationProvider>();
provider.CurrentNavigationTask.TryExecuteSynchronously(_ =>
{
try
{
var task = provider.NavigateAsync(operation.ToOperationCallback(), context);
tcs.TrySetFromTask(task);
}
catch (Exception e)
{
tcs.TrySetException(e);
throw;
}
});
return operation;
}
INavigationOperation IDynamicViewModelPresenter.TryShowAsync(IViewModel viewModel, IDataContext context, IViewModelPresenter parentPresenter)
{
parentPresenter.DynamicPresenters.Remove(this);
if (WrapToNavigationController)
return parentPresenter.ShowAsync(viewModel, context);
_window.RootViewController = (UIViewController)ViewManager.GetOrCreateView(viewModel, null, context);
return new NavigationOperation();
}
